fix build

Linie/Aufzeichnung/Aufzeichnung.cpp

@@ -6,641 +6,641 @@
 // Konstruktor
 Aufzeichnung::Aufzeichnung()
 {
-	nMsg = 0;
-	nMsgVorwärts = 0;
-	schrift = 0;
-	screen = 0;
-	nachrichten = 0;
-	bestenliste = 0;
-	chat = 0;
-	steuerung = 0;
-	kam = 0;
-	map = 0;
-	ende = 0;
-	spieler = new RCArray< VideoSpieler >();
-	spielZeit = 0;
-	rSpielZeit = new Array< double >();
-	spielPause = 1;
-	spielerAnzahl = 0;
-	teamAnzahl = 0;
-	kamSpielerNummer = -1;
-	mx = -1;
-	my = -1;
-	geladen = 0;
-	pauseZeit = -1;
-	time = 0;
-	ref = 1;
+    nMsg = 0;
+    nMsgVorwärts = 0;
+    schrift = 0;
+    screen = 0;
+    nachrichten = 0;
+    bestenliste = 0;
+    chat = 0;
+    steuerung = 0;
+    kam = 0;
+    map = 0;
+    ende = 0;
+    spieler = new RCArray< VideoSpieler >();
+    spielZeit = 0;
+    rSpielZeit = new Array< double >();
+    spielPause = 1;
+    spielerAnzahl = 0;
+    teamAnzahl = 0;
+    kamSpielerNummer = -1;
+    mx = -1;
+    my = -1;
+    geladen = 0;
+    pauseZeit = -1;
+    time = 0;
+    ref = 1;
 }
 
 // Destruktor
 Aufzeichnung::~Aufzeichnung()
 {
-	if( schrift )
-		schrift->release();
-	spieler->release();
-	if( ende )
-		ende->release();
-	if( map )
-		map->release();
-	if( kam )
-		kam->release();
-	if( steuerung )
-		steuerung->release();
-	if( chat )
-		chat->relese();
-	if( bestenliste )
-		bestenliste->release();
-	if( nachrichten )
-		nachrichten->release();
-	rSpielZeit->release();
+    if( schrift )
+        schrift->release();
+    spieler->release();
+    if( ende )
+        ende->release();
+    if( map )
+        map->release();
+    if( kam )
+        kam->release();
+    if( steuerung )
+        steuerung->release();
+    if( chat )
+        chat->relese();
+    if( bestenliste )
+        bestenliste->release();
+    if( nachrichten )
+        nachrichten->release();
+    rSpielZeit->release();
 }
 
 // nicht constant
 void Aufzeichnung::setSchrift( Schrift *schrift )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
 }
 
 void Aufzeichnung::setBildschirm( Bildschirm *zScreen )
 {
-	screen = zScreen;
+    screen = zScreen;
 }
 
 bool Aufzeichnung::ladeSpiel( int id )
 {
-	nachrichten = new SpielNachricht( id );
-	bestenliste = new VideoBestenliste( schrift->getThis() );
-	chat = new VideoChat( schrift );
-	steuerung = new VideoSteuerung( schrift, screen );
-	kam = new VideoKamera();
-	map = new VideoKarte();
-	ende = new VideoEnde( schrift );
-	Text f;
-	if( nachrichten->hatFehler( &f ) )
-	{
-		ende->setText( f );
-		ende->setSichtbar( 1 );
-		geladen = 1;
-		return 1;
-	}
-	spielerAnzahl = nachrichten->getSVD()->spielerAnzahl;
-	teamAnzahl = 0;
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		SpielerVideoDaten *dat = nachrichten->getSPVD( i );
-		if( !i )
-			kam->setSize( dat->kamBreite, dat->kamHöhe );
-		VideoSpieler *tmp = new VideoSpieler( dat );
-		bestenliste->addSpieler( tmp );
-		spieler->set( tmp, i );
-		teamAnzahl = teamAnzahl < dat->team ? dat->team : teamAnzahl;
-	}
-	teamAnzahl++;
-	bestenliste->setTeamAnzahl( teamAnzahl );
-	for( int i = 0; i < nachrichten->getTeamAnzahl(); i++ )
-	{
-		TeamVideoDaten *dat = nachrichten->getTVD( i );
-		bestenliste->setTeamMaxPunkte( dat->teamNummer, dat->maxPunkte );
-		bestenliste->setTeamPunkte( dat->teamNummer, dat->punkte );
-	}
-	RundeVideoDaten *rDat = nachrichten->getRVD();
-	map->setSize( rDat->mapBreite, rDat->mapHöhe );
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		RundeSpielerVideoDaten *dat = nachrichten->getRSVD( i );
-		spieler->z( i )->neuRunde( 1, dat, 1 );
-		bestenliste->updateSpielerStatus( spieler->z( i ) );
-	}
-	pauseZeit = 3;
-	ende->setText( "Die Aufzeichnung des Spiels wird geladen.\nRunde 1 beginnt in kürze." );
-	ende->setSichtbar( 1 );
-	geladen = 1;
-	return 1;
+    nachrichten = new SpielNachricht( id );
+    bestenliste = new VideoBestenliste( dynamic_cast<Schrift *>( schrift->getThis() ) );
+    chat = new VideoChat( schrift );
+    steuerung = new VideoSteuerung( schrift, screen );
+    kam = new VideoKamera();
+    map = new VideoKarte();
+    ende = new VideoEnde( schrift );
+    Text f;
+    if( nachrichten->hatFehler( &f ) )
+    {
+        ende->setText( f );
+        ende->setSichtbar( 1 );
+        geladen = 1;
+        return 1;
+    }
+    spielerAnzahl = nachrichten->getSVD()->spielerAnzahl;
+    teamAnzahl = 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        SpielerVideoDaten *dat = nachrichten->getSPVD( i );
+        if( !i )
+            kam->setSize( dat->kamBreite, dat->kamHöhe );
+        VideoSpieler *tmp = new VideoSpieler( dat );
+        bestenliste->addSpieler( tmp );
+        spieler->set( tmp, i );
+        teamAnzahl = teamAnzahl < dat->team ? dat->team : teamAnzahl;
+    }
+    teamAnzahl++;
+    bestenliste->setTeamAnzahl( teamAnzahl );
+    for( int i = 0; i < nachrichten->getTeamAnzahl(); i++ )
+    {
+        TeamVideoDaten *dat = nachrichten->getTVD( i );
+        bestenliste->setTeamMaxPunkte( dat->teamNummer, dat->maxPunkte );
+        bestenliste->setTeamPunkte( dat->teamNummer, dat->punkte );
+    }
+    RundeVideoDaten *rDat = nachrichten->getRVD();
+    map->setSize( rDat->mapBreite, rDat->mapHöhe );
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        RundeSpielerVideoDaten *dat = nachrichten->getRSVD( i );
+        spieler->z( i )->neuRunde( 1, dat, 1 );
+        bestenliste->updateSpielerStatus( spieler->z( i ) );
+    }
+    pauseZeit = 3;
+    ende->setText( "Die Aufzeichnung des Spiels wird geladen.\nRunde 1 beginnt in kürze." );
+    ende->setSichtbar( 1 );
+    geladen = 1;
+    return 1;
 }
 
 void Aufzeichnung::doPublicMausEreignis( MausEreignis &me )
 {
-	if( !geladen )
-		return;
-	if( kam->istMausIn( me.mx, me.my ) )
-	{
-		if( me.id == ME_PLinks )
-		{
-			for( int i = 0; i < spielerAnzahl; i++ )
-			{
-				if( spieler->z( i )->istMausIn( kam->getLinks() + me.mx - kam->getRX( kam->getLinks() ), kam->getOben() + me.my - kam->getRY( kam->getOben() ) ) )
-				{
-					kamSpielerNummer = spieler->z( i )->getSpielerNummer();
-					me.verarbeitet = 1;
-					break;
-				}
-			}
-		}
-		if( ( me.id == ME_RLinks || me.id == ME_RRechts ) && mx >= 0 )
-		{
-			mx = -1;
-			my = -1;
-		}
-		if( me.id == ME_Bewegung && mx >= 0 )
-		{
-			kam->addPosition( mx - me.mx, my - me.my, map );
-			mx = me.mx;
-			my = me.my;
-		}
-		if( ( me.id == ME_PLinks || me.id == ME_PRechts ) && mx < 0 && !me.verarbeitet )
-		{
-			mx = me.mx;
-			my = me.my;
-			kamSpielerNummer = -1;
-		}
-		me.verarbeitet = 1;
-	}
-	else
-	{
-		mx = -1;
-		my = -1;
-	}
-	bestenliste->doPublicMausEreignis( me );
-	steuerung->doPublicMausEreignis( me );
+    if( !geladen )
+        return;
+    if( kam->istMausIn( me.mx, me.my ) )
+    {
+        if( me.id == ME_PLinks )
+        {
+            for( int i = 0; i < spielerAnzahl; i++ )
+            {
+                if( spieler->z( i )->istMausIn( kam->getLinks() + me.mx - kam->getRX( kam->getLinks() ), kam->getOben() + me.my - kam->getRY( kam->getOben() ) ) )
+                {
+                    kamSpielerNummer = spieler->z( i )->getSpielerNummer();
+                    me.verarbeitet = 1;
+                    break;
+                }
+            }
+        }
+        if( ( me.id == ME_RLinks || me.id == ME_RRechts ) && mx >= 0 )
+        {
+            mx = -1;
+            my = -1;
+        }
+        if( me.id == ME_Bewegung && mx >= 0 )
+        {
+            kam->addPosition( mx - me.mx, my - me.my, map );
+            mx = me.mx;
+            my = me.my;
+        }
+        if( ( me.id == ME_PLinks || me.id == ME_PRechts ) && mx < 0 && !me.verarbeitet )
+        {
+            mx = me.mx;
+            my = me.my;
+            kamSpielerNummer = -1;
+        }
+        me.verarbeitet = 1;
+    }
+    else
+    {
+        mx = -1;
+        my = -1;
+    }
+    bestenliste->doPublicMausEreignis( me );
+    steuerung->doPublicMausEreignis( me );
 }
 
 void Aufzeichnung::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( !geladen )
-		return;
-	if( te.id == TE_Press )
-	{
-		switch( te.taste )
-		{
-		case T_Links:
-			kam->addPosition( -2, 0, map );
-			te.verarbeitet = 1;
-			break;
-		case T_Oben:
-			kam->addPosition( 0, -2, map );
-			te.verarbeitet = 1;
-			break;
-		case T_Rechts:
-			kam->addPosition( 2, 0, map );
-			te.verarbeitet = 1;
-			break;
-		case T_Unten:
-			kam->addPosition( 0, 2, map );
-			te.verarbeitet = 1;
-			break;
-		}
-		if( te.verarbeitet )
-			kamSpielerNummer = -1;
-	}
+    if( !geladen )
+        return;
+    if( te.id == TE_Press )
+    {
+        switch( te.taste )
+        {
+        case T_Links:
+            kam->addPosition( -2, 0, map );
+            te.verarbeitet = 1;
+            break;
+        case T_Oben:
+            kam->addPosition( 0, -2, map );
+            te.verarbeitet = 1;
+            break;
+        case T_Rechts:
+            kam->addPosition( 2, 0, map );
+            te.verarbeitet = 1;
+            break;
+        case T_Unten:
+            kam->addPosition( 0, 2, map );
+            te.verarbeitet = 1;
+            break;
+        }
+        if( te.verarbeitet )
+            kamSpielerNummer = -1;
+    }
 }
 
 bool Aufzeichnung::spielTick( double spielZeit )
 {
-	this->spielZeit += spielZeit;
-	bool setKam = kamSpielerNummer >= 0;
-	int x = 0;
-	int y = 0;
-	bool rEnd = 0;
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		VideoSpieler *tmp = spieler->z( i );
-		if( tmp )
-		{
-			if( tmp->getSpielerNummer() == kamSpielerNummer )
-			{
-				x = (int)( tmp->getX() + 0.5 );
-				y = (int)( tmp->getY() + 0.5 );
-			}
-			bool amLeben = tmp->istAmLeben();
-			tmp->tick( map->zMap(), spielZeit );
-			if( amLeben != tmp->istAmLeben() )
-			{
-				bestenliste->updateSpielerStatus( tmp );
-				for( int j = 0; j < spielerAnzahl; j++ )
-				{
-					VideoSpieler *s = spieler->z( j );
-					if( s && s != tmp && s->istAmLeben() )
-						bestenliste->addPunkt( s->getTeam(), s->getSpielerNummer(), spielZeit > 0 );
-				}
-			}
-			if( amLeben && !tmp->istAmLeben() )
-			{ // gestorben
-				int team = tmp->getTeam();
-				bool teamLebt = 0;
-				for( int k = 0; k < spielerAnzahl; k++ )
-				{
-					if( spieler->z( k ) && spieler->z( k )->getTeam() == team )
-						teamLebt |= spieler->z( k )->istAmLeben();
-				}
-				if( !teamLebt )
-				{
-					int teamAmLebenAnzahl = 0;
-					for( int k = 0; k < teamAnzahl; k++ )
-					{
-						if( !bestenliste->teamExistiert( k ) )
-							continue;
-						bool amLeben = 0;
-						for( int l = 0; l < spielerAnzahl; l++ )
-						{
-							if( spieler->z( l ) && spieler->z( l )->getTeam() == k )
-								amLeben |= spieler->z( l )->istAmLeben();
-						}
-						if( amLeben )
-						{
-							teamAmLebenAnzahl++;
-							bestenliste->addPunkt( k, 1 );
-						}
-						else
-							bestenliste->addPunkt( k, 0 );
-						if( !bestenliste->getTeamPunkte( k ) )
-							bestenliste->setTeamStatus( k, "tod", 0xFFFF0000 );
-					}
-					if( teamAmLebenAnzahl <= 1 )
-						rEnd = 1;
-				}
-			}
-			if( !amLeben && tmp->istAmLeben() )
-			{ // Wiederbelebt
-				int team = tmp->getTeam();
-				bool teamLebt = 0;
-				for( int k = 0; k < spielerAnzahl; k++ )
-				{
-					if( k != i && spieler->z( k ) && spieler->z( k )->getTeam() == team )
-						teamLebt |= spieler->z( k )->istAmLeben();
-				}
-				if( !teamLebt )
-				{
-					for( int k = 0; k < teamAnzahl; k++ )
-					{
-						if( !bestenliste->teamExistiert( k ) )
-							continue;
-						bool amLeben = 0;
-						for( int l = 0; l < spielerAnzahl; l++ )
-						{
-							if( l != i && spieler->z( l ) && spieler->z( l )->getTeam() == k )
-								amLeben |= spieler->z( l )->istAmLeben();
-						}
-						if( amLeben )
-							bestenliste->addPunkt( k, 0 );
-						else
-							bestenliste->addPunkt( k, 1 );
-						if( bestenliste->getTeamPunkte( k ) )
-							bestenliste->setTeamStatus( k, "lebt", 0xFF00FF00 );
-					}
-				}
-			}
-		}
-	}
-	if( setKam )
-	{
-		double z = spielZeit < 0 ? -spielZeit : spielZeit;
-		double px = ( ( x - kam->getX() ) / 100.0 ) * ( 50 * z );
-		double py = ( ( y - kam->getY() ) / 100.0 ) * ( 50 * z );
-		kam->addPosition( (int)px, (int)py, map );
-	}
-	chat->tick( spielZeit );
-	steuerung->tick( spielZeit );
-	if( rEnd && spielZeit > 0 )
-	{ // Runden Ende
-		int nAnz = 0;
-		int nAnz2 = 0;
-		for( int i = 0; i < teamAnzahl; i++ )
-		{
-			if( bestenliste->teamExistiert( i ) )
-			{
-				nAnz += bestenliste->hatTeamGewonnen( i );
-				nAnz2 += bestenliste->getTeamPunkte( i ) >= 0;
-			}
-		}
-		if( nAnz || nAnz2 <= 1 || nachrichten->getRunde() >= 9 )
-		{ // Spiel Ende
-			steuerung->pause( 1 );
-			return 1;
-		}
-		spielPause = 1;
-		pauseZeit = 2;
-		ende->setText( "Die nächste Runde beginnt in kürze." );
-		ende->setSichtbar( 1 );
-		int r = nachrichten->setRundenEnde( 1 );
-		rSpielZeit->set( spielZeit, r - 1 );
-		this->spielZeit = 0;
-		time = 0;
-		bestenliste->updatePunkte();
-		kam->nextRunde( 1 );
-		map->nextRunde( 1 );
-		RundeVideoDaten *dat = nachrichten->getRVD();
-		map->setSize( dat->mapBreite, dat->mapHöhe );
-		for( int i = 0; i < spielerAnzahl; i++ )
-		{
-			spieler->z( i )->neuRunde( 1, nachrichten->getRSVD( i ), bestenliste->getTeamPunkte( spieler->z( i )->getTeam() ) != 0 );
-			bestenliste->updateSpielerStatus( spieler->z( i ) );
-		}
-		return 1;
-	}
-	return 0;
+    this->spielZeit += spielZeit;
+    bool setKam = kamSpielerNummer >= 0;
+    int x = 0;
+    int y = 0;
+    bool rEnd = 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        VideoSpieler *tmp = spieler->z( i );
+        if( tmp )
+        {
+            if( tmp->getSpielerNummer() == kamSpielerNummer )
+            {
+                x = (int)( tmp->getX() + 0.5 );
+                y = (int)( tmp->getY() + 0.5 );
+            }
+            bool amLeben = tmp->istAmLeben();
+            tmp->tick( map->zMap(), spielZeit );
+            if( amLeben != tmp->istAmLeben() )
+            {
+                bestenliste->updateSpielerStatus( tmp );
+                for( int j = 0; j < spielerAnzahl; j++ )
+                {
+                    VideoSpieler *s = spieler->z( j );
+                    if( s && s != tmp && s->istAmLeben() )
+                        bestenliste->addPunkt( s->getTeam(), s->getSpielerNummer(), spielZeit > 0 );
+                }
+            }
+            if( amLeben && !tmp->istAmLeben() )
+            { // gestorben
+                int team = tmp->getTeam();
+                bool teamLebt = 0;
+                for( int k = 0; k < spielerAnzahl; k++ )
+                {
+                    if( spieler->z( k ) && spieler->z( k )->getTeam() == team )
+                        teamLebt |= spieler->z( k )->istAmLeben();
+                }
+                if( !teamLebt )
+                {
+                    int teamAmLebenAnzahl = 0;
+                    for( int k = 0; k < teamAnzahl; k++ )
+                    {
+                        if( !bestenliste->teamExistiert( k ) )
+                            continue;
+                        bool amLeben = 0;
+                        for( int l = 0; l < spielerAnzahl; l++ )
+                        {
+                            if( spieler->z( l ) && spieler->z( l )->getTeam() == k )
+                                amLeben |= spieler->z( l )->istAmLeben();
+                        }
+                        if( amLeben )
+                        {
+                            teamAmLebenAnzahl++;
+                            bestenliste->addPunkt( k, 1 );
+                        }
+                        else
+                            bestenliste->addPunkt( k, 0 );
+                        if( !bestenliste->getTeamPunkte( k ) )
+                            bestenliste->setTeamStatus( k, "tod", 0xFFFF0000 );
+                    }
+                    if( teamAmLebenAnzahl <= 1 )
+                        rEnd = 1;
+                }
+            }
+            if( !amLeben && tmp->istAmLeben() )
+            { // Wiederbelebt
+                int team = tmp->getTeam();
+                bool teamLebt = 0;
+                for( int k = 0; k < spielerAnzahl; k++ )
+                {
+                    if( k != i && spieler->z( k ) && spieler->z( k )->getTeam() == team )
+                        teamLebt |= spieler->z( k )->istAmLeben();
+                }
+                if( !teamLebt )
+                {
+                    for( int k = 0; k < teamAnzahl; k++ )
+                    {
+                        if( !bestenliste->teamExistiert( k ) )
+                            continue;
+                        bool amLeben = 0;
+                        for( int l = 0; l < spielerAnzahl; l++ )
+                        {
+                            if( l != i && spieler->z( l ) && spieler->z( l )->getTeam() == k )
+                                amLeben |= spieler->z( l )->istAmLeben();
+                        }
+                        if( amLeben )
+                            bestenliste->addPunkt( k, 0 );
+                        else
+                            bestenliste->addPunkt( k, 1 );
+                        if( bestenliste->getTeamPunkte( k ) )
+                            bestenliste->setTeamStatus( k, "lebt", 0xFF00FF00 );
+                    }
+                }
+            }
+        }
+    }
+    if( setKam )
+    {
+        double z = spielZeit < 0 ? -spielZeit : spielZeit;
+        double px = ( ( x - kam->getX() ) / 100.0 ) * ( 50 * z );
+        double py = ( ( y - kam->getY() ) / 100.0 ) * ( 50 * z );
+        kam->addPosition( (int)px, (int)py, map );
+    }
+    chat->tick( spielZeit );
+    steuerung->tick( spielZeit );
+    if( rEnd && spielZeit > 0 )
+    { // Runden Ende
+        int nAnz = 0;
+        int nAnz2 = 0;
+        for( int i = 0; i < teamAnzahl; i++ )
+        {
+            if( bestenliste->teamExistiert( i ) )
+            {
+                nAnz += bestenliste->hatTeamGewonnen( i );
+                nAnz2 += bestenliste->getTeamPunkte( i ) >= 0;
+            }
+        }
+        if( nAnz || nAnz2 <= 1 || nachrichten->getRunde() >= 9 )
+        { // Spiel Ende
+            steuerung->pause( 1 );
+            return 1;
+        }
+        spielPause = 1;
+        pauseZeit = 2;
+        ende->setText( "Die nächste Runde beginnt in kürze." );
+        ende->setSichtbar( 1 );
+        int r = nachrichten->setRundenEnde( 1 );
+        rSpielZeit->set( spielZeit, r - 1 );
+        this->spielZeit = 0;
+        time = 0;
+        bestenliste->updatePunkte();
+        kam->nextRunde( 1 );
+        map->nextRunde( 1 );
+        RundeVideoDaten *dat = nachrichten->getRVD();
+        map->setSize( dat->mapBreite, dat->mapHöhe );
+        for( int i = 0; i < spielerAnzahl; i++ )
+        {
+            spieler->z( i )->neuRunde( 1, nachrichten->getRSVD( i ), bestenliste->getTeamPunkte( spieler->z( i )->getTeam() ) != 0 );
+            bestenliste->updateSpielerStatus( spieler->z( i ) );
+        }
+        return 1;
+    }
+    return 0;
 }
 
 bool Aufzeichnung::tick( double tickVal )
 {
-	if( !geladen )
-		return 0;
-	if( spielPause )
-	{
-		if( pauseZeit >= 0 )
-		{
-			pauseZeit -= tickVal;
-			if( pauseZeit < 0 )
-			{
-				pauseZeit = 0;
-				spielPause = 0;
-				ende->setSichtbar( 0 );
-			}
-		}
-		chat->tick( 0 );
-		steuerung->tick( 0 );
-		return 1;
-	}
-	if( ( steuerung->istVorwärts() || nMsg && nMsgVorwärts ) && !( nMsg && !nMsgVorwärts ) )
-	{
-		if( steuerung->istZeitlupe() )
-			time += tickVal / steuerung->getSpeed();
-		else
-			time += tickVal * steuerung->getSpeed();
-		while( steuerung->getSpeed() != 0 )
-		{
-			while( !nMsg || nMsg->typ && steuerung->getSpeed() != 0 )
-			{
-				if( !nMsg )
-					nMsg = nachrichten->GetNextNachricht();
-				if( !nMsg )
-					break;
-				nMsgVorwärts = 1;
-				if( !nMsg->typ )
-					break;
-				VideoAktionMSG *ak = (VideoAktionMSG*)nMsg;
-				switch( ak->aktion )
-				{
-				case 0: // T_Links Press
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setLinksKurve( 1 );
-							break;
-						}
-					}
-					break;
-				case 1: // T_Links Release
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setLinksKurve( 0 );
-							break;
-						}
-					}
-					break;
-				case 2: // T_Rechts Press
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setRechtsKurve( 1 );
-							break;
-						}
-					}
-					break;
-				case 3: // T_Rechts Release
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setRechtsKurve( 0 );
-							break;
-						}
-					}
-					break;
-				case 4: // Chat Nachricht
-					if( 1 )
-					{
-						VideoChatMSG *msg = (VideoChatMSG*)ak;
-						for( int i = 0; i < spielerAnzahl; i++ )
-						{
-							if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-							{
-								Text txt = spieler->z( i )->zName()->getText();
-								txt += ": ";
-								txt += msg->msg.getText();
-								chat->addNachricht( txt );
-								break;
-							}
-						}
-					}
-					break;
-				case 5: // Linien Unterbrechung
-					if( 1 )
-					{
-						VideoLinieMSG *lMsg = (VideoLinieMSG*)ak;
-						for( int i = 0; i < spielerAnzahl; i++ )
-						{
-							if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-							{
-								spieler->z( i )->setLinienUnterbrechung( lMsg->unterbrechung != 0 );
-								break;
-							}
-						}
-					}
-					break;
-				}
-				nMsg = 0;
-			}
-			if( !nMsg )
-				break;
-			if( time > spielZeit + TICK )
-			{
-				bool end = spielTick( TICK );
-				nMsg = 0;
-				if( !steuerung->istVorwärts() || end )
-					break;
-			}
-			else
-				break;
-		}
-	}
-	else
-	{
-		if( steuerung->istZeitlupe() )
-			time -= tickVal / steuerung->getSpeed();
-		else
-			time -= tickVal * steuerung->getSpeed();
-		while( 1 )
-		{
-			while( !nMsg || nMsg->typ )
-			{
-				if( !nMsg )
-				{
-					nMsg = nachrichten->GetLastNachricht();
-					nMsgVorwärts = 0;
-					if( !nMsg )
-					{
-						int r = nachrichten->setRundenEnde( 0 );
-						if( r < 0 )
-						{ // Spiel Beginn
-							steuerung->pause( 0 );
-							return 1;
-						}
-						bestenliste->updatePunkte( 0 );
-						kam->nextRunde( 0 );
-						map->nextRunde( 0 );
-						for( int i = 0; i < spielerAnzahl; i++ )
-							spieler->z( i )->neuRunde( 0, 0, 1 );
-						spielPause = 1;
-						pauseZeit = 2;
-						ende->setText( "Vorherige Runde beginnt in kürze." );
-						ende->setSichtbar( 1 );
-						spielZeit = rSpielZeit->get( r );
-						time = spielZeit;
-						return 1;
-					}
-				}
-				if( !nMsg->typ )
-					break;
-				VideoAktionMSG *ak = (VideoAktionMSG*)nMsg;
-				switch( ak->aktion )
-				{
-				case 0: // T_Links Press
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setLinksKurve( 0 );
-							break;
-						}
-					}
-					break;
-				case 1: // T_Links Release
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setLinksKurve( 1 );
-							break;
-						}
-					}
-					break;
-				case 2: // T_Rechts Press
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setRechtsKurve( 0 );
-							break;
-						}
-					}
-					break;
-				case 3: // T_Rechts Release
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-						{
-							spieler->z( i )->setRechtsKurve( 1 );
-							break;
-						}
-					}
-					break;
-				case 4: // Chat Nachricht
-					if( 1 )
-					{
-						VideoChatMSG *msg = (VideoChatMSG*)ak;
-						for( int i = 0; i < spielerAnzahl; i++ )
-						{
-							if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-							{
-								Text txt = spieler->z( i )->zName()->getText();
-								txt += ": ";
-								txt += msg->msg.getText();
-								chat->removeNachricht( txt );
-								break;
-							}
-						}
-					}
-					break;
-				case 5: // Linien Unterbrechung
-					if( 1 )
-					{
-						VideoLinieMSG *lMsg = (VideoLinieMSG*)ak;
-						if( 1 )
-						{
-							for( int i = 0; i < spielerAnzahl; i++ )
-							{
-								if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
-								{
-									spieler->z( i )->setLinienUnterbrechung( lMsg->unterbrechung == 0 );
-									break;
-								}
-							}
-						}
-					}
-					break;
-				}
-				nMsg = 0;
-			}
-			if( time <= spielZeit - TICK )
-			{
-				spielTick( -TICK );
-				nMsg = 0;
-				if( steuerung->istVorwärts() )
-					break;
-			}
-			else
-				break;
-		}
-	}
-	return 1;
+    if( !geladen )
+        return 0;
+    if( spielPause )
+    {
+        if( pauseZeit >= 0 )
+        {
+            pauseZeit -= tickVal;
+            if( pauseZeit < 0 )
+            {
+                pauseZeit = 0;
+                spielPause = 0;
+                ende->setSichtbar( 0 );
+            }
+        }
+        chat->tick( 0 );
+        steuerung->tick( 0 );
+        return 1;
+    }
+    if( ( steuerung->istVorwärts() || nMsg && nMsgVorwärts ) && !( nMsg && !nMsgVorwärts ) )
+    {
+        if( steuerung->istZeitlupe() )
+            time += tickVal / steuerung->getSpeed();
+        else
+            time += tickVal * steuerung->getSpeed();
+        while( steuerung->getSpeed() != 0 )
+        {
+            while( !nMsg || nMsg->typ && steuerung->getSpeed() != 0 )
+            {
+                if( !nMsg )
+                    nMsg = nachrichten->GetNextNachricht();
+                if( !nMsg )
+                    break;
+                nMsgVorwärts = 1;
+                if( !nMsg->typ )
+                    break;
+                VideoAktionMSG *ak = (VideoAktionMSG *)nMsg;
+                switch( ak->aktion )
+                {
+                case 0: // T_Links Press
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setLinksKurve( 1 );
+                            break;
+                        }
+                    }
+                    break;
+                case 1: // T_Links Release
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setLinksKurve( 0 );
+                            break;
+                        }
+                    }
+                    break;
+                case 2: // T_Rechts Press
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setRechtsKurve( 1 );
+                            break;
+                        }
+                    }
+                    break;
+                case 3: // T_Rechts Release
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setRechtsKurve( 0 );
+                            break;
+                        }
+                    }
+                    break;
+                case 4: // Chat Nachricht
+                    if( 1 )
+                    {
+                        VideoChatMSG *msg = (VideoChatMSG *)ak;
+                        for( int i = 0; i < spielerAnzahl; i++ )
+                        {
+                            if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                            {
+                                Text txt = spieler->z( i )->zName()->getText();
+                                txt += ": ";
+                                txt += msg->msg.getText();
+                                chat->addNachricht( txt );
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                case 5: // Linien Unterbrechung
+                    if( 1 )
+                    {
+                        VideoLinieMSG *lMsg = (VideoLinieMSG *)ak;
+                        for( int i = 0; i < spielerAnzahl; i++ )
+                        {
+                            if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                            {
+                                spieler->z( i )->setLinienUnterbrechung( lMsg->unterbrechung != 0 );
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                }
+                nMsg = 0;
+            }
+            if( !nMsg )
+                break;
+            if( time > spielZeit + TICK )
+            {
+                bool end = spielTick( TICK );
+                nMsg = 0;
+                if( !steuerung->istVorwärts() || end )
+                    break;
+            }
+            else
+                break;
+        }
+    }
+    else
+    {
+        if( steuerung->istZeitlupe() )
+            time -= tickVal / steuerung->getSpeed();
+        else
+            time -= tickVal * steuerung->getSpeed();
+        while( 1 )
+        {
+            while( !nMsg || nMsg->typ )
+            {
+                if( !nMsg )
+                {
+                    nMsg = nachrichten->GetLastNachricht();
+                    nMsgVorwärts = 0;
+                    if( !nMsg )
+                    {
+                        int r = nachrichten->setRundenEnde( 0 );
+                        if( r < 0 )
+                        { // Spiel Beginn
+                            steuerung->pause( 0 );
+                            return 1;
+                        }
+                        bestenliste->updatePunkte( 0 );
+                        kam->nextRunde( 0 );
+                        map->nextRunde( 0 );
+                        for( int i = 0; i < spielerAnzahl; i++ )
+                            spieler->z( i )->neuRunde( 0, 0, 1 );
+                        spielPause = 1;
+                        pauseZeit = 2;
+                        ende->setText( "Vorherige Runde beginnt in kürze." );
+                        ende->setSichtbar( 1 );
+                        spielZeit = rSpielZeit->get( r );
+                        time = spielZeit;
+                        return 1;
+                    }
+                }
+                if( !nMsg->typ )
+                    break;
+                VideoAktionMSG *ak = (VideoAktionMSG *)nMsg;
+                switch( ak->aktion )
+                {
+                case 0: // T_Links Press
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setLinksKurve( 0 );
+                            break;
+                        }
+                    }
+                    break;
+                case 1: // T_Links Release
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setLinksKurve( 1 );
+                            break;
+                        }
+                    }
+                    break;
+                case 2: // T_Rechts Press
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setRechtsKurve( 0 );
+                            break;
+                        }
+                    }
+                    break;
+                case 3: // T_Rechts Release
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                        {
+                            spieler->z( i )->setRechtsKurve( 1 );
+                            break;
+                        }
+                    }
+                    break;
+                case 4: // Chat Nachricht
+                    if( 1 )
+                    {
+                        VideoChatMSG *msg = (VideoChatMSG *)ak;
+                        for( int i = 0; i < spielerAnzahl; i++ )
+                        {
+                            if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                            {
+                                Text txt = spieler->z( i )->zName()->getText();
+                                txt += ": ";
+                                txt += msg->msg.getText();
+                                chat->removeNachricht( txt );
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                case 5: // Linien Unterbrechung
+                    if( 1 )
+                    {
+                        VideoLinieMSG *lMsg = (VideoLinieMSG *)ak;
+                        if( 1 )
+                        {
+                            for( int i = 0; i < spielerAnzahl; i++ )
+                            {
+                                if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
+                                {
+                                    spieler->z( i )->setLinienUnterbrechung( lMsg->unterbrechung == 0 );
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+                nMsg = 0;
+            }
+            if( time <= spielZeit - TICK )
+            {
+                spielTick( -TICK );
+                nMsg = 0;
+                if( steuerung->istVorwärts() )
+                    break;
+            }
+            else
+                break;
+        }
+    }
+    return 1;
 }
 
 void Aufzeichnung::render( Bild &zRObj )
 {
-	if( !geladen )
-		return;
-	bestenliste->render( zRObj );
-	chat->render( zRObj );
-	steuerung->render( zRObj );
-	kam->render( zRObj );
-	int x = kam->getRX( kam->getLinks() ) + 1, y = kam->getRY( kam->getOben() ) + 1;
-	if( zRObj.setDrawOptions( x, y, kam->getRechts() - kam->getLinks() - 2, kam->getUnten() - kam->getOben() - 2 ) )
-	{
-		zRObj.addScrollOffset( x, y );
-		map->render( kam, zRObj );
-		for( int i = 0; i < spielerAnzahl; i++ )
-			spieler->z( i )->render( kam, zRObj );
-		zRObj.releaseDrawOptions();
-	}
-	if( ende )
-		ende->render( zRObj );
+    if( !geladen )
+        return;
+    bestenliste->render( zRObj );
+    chat->render( zRObj );
+    steuerung->render( zRObj );
+    kam->render( zRObj );
+    int x = kam->getRX( kam->getLinks() ) + 1, y = kam->getRY( kam->getOben() ) + 1;
+    if( zRObj.setDrawOptions( x, y, kam->getRechts() - kam->getLinks() - 2, kam->getUnten() - kam->getOben() - 2 ) )
+    {
+        zRObj.addScrollOffset( x, y );
+        map->render( kam, zRObj );
+        for( int i = 0; i < spielerAnzahl; i++ )
+            spieler->z( i )->render( kam, zRObj );
+        zRObj.releaseDrawOptions();
+    }
+    if( ende )
+        ende->render( zRObj );
 }
 
 // constant
 bool Aufzeichnung::hatVerlassen( bool jetzt ) const
 {
-	if( !geladen )
-		return 0;
-	return steuerung->istBeendet( jetzt );
+    if( !geladen )
+        return 0;
+    return steuerung->istBeendet( jetzt );
 }
 
 // Reference Counting
 AufzeichnungV *Aufzeichnung::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 AufzeichnungV *Aufzeichnung::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Aufzeichnung/Bestenliste/VideoBestenliste.cpp

@@ -11,704 +11,704 @@
 // Konstruktor
 VideoBLSpieler::VideoBLSpieler( int sNum, int farbe, Schrift *zS )
 {
-	this->sNum = sNum;
-	this->farbe = farbe;
-	p = 0;
-	nP = 0;
-
-	rahmen = new LRahmen();
-	rahmen->setFarbe( farbe );
-	rahmen->setRamenBreite( 1 );
-	rahmen->setSize( 400, 20 );
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( zS )
-	     name->setSchriftZ( zS->getThis() );
-	name->setSchriftFarbe( farbe );
-	name->setSchriftSize( 12 );
-	name->setSize( 100, 20 );
-	name->setPosition( 0, 0 );
-	name->setText( "" );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( zS )
-	    punkte->setSchriftZ( zS->getThis() );
-	punkte->setSchriftFarbe( farbe );
-	punkte->setSchriftSize( 12 );
-	punkte->setSize( 100, 20 );
-	punkte->setPosition( 100, 0 );
-	punkte->setText( "" );
-
-	neuPunkte = new TextFeld();
-	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( zS )
-	    neuPunkte->setSchriftZ( zS->getThis() );
-	neuPunkte->setSchriftFarbe( farbe );
-	neuPunkte->setSchriftSize( 12 );
-	neuPunkte->setSize( 100, 20 );
-	neuPunkte->setPosition( 200, 0 );
-	neuPunkte->setText( "" );
-
-	status = new TextFeld();
-	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( zS )
-	    status->setSchriftZ( zS->getThis() );
-	status->setSchriftFarbe( 0xFF00FF00 );
-	status->setSchriftSize( 12 );
-	status->setSize( 100, 20 );
-	status->setPosition( 300, 0 );
-	status->setText( "lebt" );
-
-	rundenNP = new Array< int >();
-	runde = 0;
-
-	ref = 1;
+    this->sNum = sNum;
+    this->farbe = farbe;
+    p = 0;
+    nP = 0;
+
+    rahmen = new LRahmen();
+    rahmen->setFarbe( farbe );
+    rahmen->setRamenBreite( 1 );
+    rahmen->setSize( 400, 20 );
+
+    name = new TextFeld();
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( zS )
+        name->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    name->setSchriftFarbe( farbe );
+    name->setSchriftSize( 12 );
+    name->setSize( 100, 20 );
+    name->setPosition( 0, 0 );
+    name->setText( "" );
+
+    punkte = new TextFeld();
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( zS )
+        punkte->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    punkte->setSchriftFarbe( farbe );
+    punkte->setSchriftSize( 12 );
+    punkte->setSize( 100, 20 );
+    punkte->setPosition( 100, 0 );
+    punkte->setText( "" );
+
+    neuPunkte = new TextFeld();
+    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( zS )
+        neuPunkte->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    neuPunkte->setSchriftFarbe( farbe );
+    neuPunkte->setSchriftSize( 12 );
+    neuPunkte->setSize( 100, 20 );
+    neuPunkte->setPosition( 200, 0 );
+    neuPunkte->setText( "" );
+
+    status = new TextFeld();
+    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( zS )
+        status->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    status->setSchriftFarbe( 0xFF00FF00 );
+    status->setSchriftSize( 12 );
+    status->setSize( 100, 20 );
+    status->setPosition( 300, 0 );
+    status->setText( "lebt" );
+
+    rundenNP = new Array< int >();
+    runde = 0;
+
+    ref = 1;
 }
 
 // Destruktor
 VideoBLSpieler::~VideoBLSpieler()
 {
-	rahmen->release();
-	name->release();
-	punkte->release();
-	neuPunkte->release();
-	status->release();
-	rundenNP->release();
+    rahmen->release();
+    name->release();
+    punkte->release();
+    neuPunkte->release();
+    status->release();
+    rundenNP->release();
 }
 
 // nicht constant
 bool VideoBLSpieler::updateStatus( VideoSpieler *zSpieler )
 {
-	if( sNum != zSpieler->getSpielerNummer() )
-		return 0;
-	if( zSpieler->istAmLeben() )
-	{
-		status->setSchriftFarbe( 0xFF00FF00 );
-		status->setText( "lebt" );
-	}
-	else
-	{
-		status->setSchriftFarbe( 0xFFFF0000 );
-		status->setText( "tot" );
-	}
-	name->setText( zSpieler->zName()->getText() );
-	return 1;
+    if( sNum != zSpieler->getSpielerNummer() )
+        return 0;
+    if( zSpieler->istAmLeben() )
+    {
+        status->setSchriftFarbe( 0xFF00FF00 );
+        status->setText( "lebt" );
+    }
+    else
+    {
+        status->setSchriftFarbe( 0xFFFF0000 );
+        status->setText( "tot" );
+    }
+    name->setText( zSpieler->zName()->getText() );
+    return 1;
 }
 
 void VideoBLSpieler::setPunkte( int p )
 {
-	this->p = p;
+    this->p = p;
 }
 
 void VideoBLSpieler::addPunkt( bool plus )
 {
-	if( plus )
-		nP++;
-	else
-		nP--;
+    if( plus )
+        nP++;
+    else
+        nP--;
 }
 
 void VideoBLSpieler::updatePunkte( bool vorwärts )
 {
-	if( vorwärts )
-	{
-		p += nP;
-		rundenNP->set( nP, runde );
-		nP = 0;
-		runde++;
-	}
-	else
-	{
-		runde--;
-		nP = rundenNP->get( runde );
-		p -= nP;
-	}
+    if( vorwärts )
+    {
+        p += nP;
+        rundenNP->set( nP, runde );
+        nP = 0;
+        runde++;
+    }
+    else
+    {
+        runde--;
+        nP = rundenNP->get( runde );
+        p -= nP;
+    }
 }
 
 void VideoBLSpieler::render( int y, Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	punkte->setText( "" );
-	if( nP == 0 )
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
-	}
-	else if( nP > 0 )
-	{
-		neuPunkte->setText( "+" );
-		neuPunkte->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFF0000 );
-	}
-	punkte->zText()->append( p > 0 ? p : 0 );
-	neuPunkte->zText()->append( nP );
-	rahmen->render( zRObj );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	neuPunkte->render( zRObj );
-	status->render( zRObj );
-	zRObj.releaseDrawOptions();
+    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    punkte->setText( "" );
+    if( nP == 0 )
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
+    }
+    else if( nP > 0 )
+    {
+        neuPunkte->setText( "+" );
+        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
+    }
+    punkte->zText()->append( p > 0 ? p : 0 );
+    neuPunkte->zText()->append( nP );
+    rahmen->render( zRObj );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    neuPunkte->render( zRObj );
+    status->render( zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int VideoBLSpieler::getSpielerNummer() const
 {
-	return sNum;
+    return sNum;
 }
 
 int VideoBLSpieler::getPunkte() const
 {
-	return p + nP;
+    return p + nP;
 }
 
 // Reference Counting
 VideoBLSpieler *VideoBLSpieler::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 VideoBLSpieler *VideoBLSpieler::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der VideoBLTeam Klasse aus VideoBestenliste.h
 // Konstruktor
 VideoBLTeam::VideoBLTeam( int id, int farbe, Schrift *s, char *n )
 {
-	teamId = id;
-	spielerAnzahl = 0;
-	p = 0;
-	mP = 0;
-	nP = 0;
-	this->farbe = farbe;
-	schrift = s;
-
-	rahmen = new LRahmen();
-	rahmen->setFarbe( farbe );
-	rahmen->setRamenBreite( 1 );
-
-	spieler = new RCArray< VideoBLSpieler >();
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    name->setSchriftZ( s->getThis() );
-	name->setSchriftFarbe( farbe );
-	name->setSchriftSize( 12 );
-	name->setSize( 100, 20 );
-	name->setPosition( 0, 0 );
-	name->setText( n );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    punkte->setSchriftZ( s->getThis() );
-	punkte->setSchriftFarbe( farbe );
-	punkte->setSchriftSize( 12 );
-	punkte->setSize( 100, 20 );
-	punkte->setPosition( 100, 0 );
-	punkte->setText( "" );
-
-	neuPunkte = new TextFeld();
-	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    neuPunkte->setSchriftZ( s->getThis() );
-	neuPunkte->setSchriftFarbe( farbe );
-	neuPunkte->setSchriftSize( 12 );
-	neuPunkte->setSize( 100, 20 );
-	neuPunkte->setPosition( 200, 0 );
-	neuPunkte->setText( "" );
-
-	status = new TextFeld();
-	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    status->setSchriftZ( s->getThis() );
-	status->setSchriftFarbe( 0xFF00FF00 );
-	status->setSchriftSize( 12 );
-	status->setSize( 100, 20 );
-	status->setPosition( 300, 0 );
-	status->setText( "lebt" );
-
-	rundenNP = new Array< int >();
-	runde = 0;
-
-	ref = 1;
+    teamId = id;
+    spielerAnzahl = 0;
+    p = 0;
+    mP = 0;
+    nP = 0;
+    this->farbe = farbe;
+    schrift = s;
+
+    rahmen = new LRahmen();
+    rahmen->setFarbe( farbe );
+    rahmen->setRamenBreite( 1 );
+
+    spieler = new RCArray< VideoBLSpieler >();
+
+    name = new TextFeld();
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        name->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    name->setSchriftFarbe( farbe );
+    name->setSchriftSize( 12 );
+    name->setSize( 100, 20 );
+    name->setPosition( 0, 0 );
+    name->setText( n );
+
+    punkte = new TextFeld();
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        punkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    punkte->setSchriftFarbe( farbe );
+    punkte->setSchriftSize( 12 );
+    punkte->setSize( 100, 20 );
+    punkte->setPosition( 100, 0 );
+    punkte->setText( "" );
+
+    neuPunkte = new TextFeld();
+    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        neuPunkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    neuPunkte->setSchriftFarbe( farbe );
+    neuPunkte->setSchriftSize( 12 );
+    neuPunkte->setSize( 100, 20 );
+    neuPunkte->setPosition( 200, 0 );
+    neuPunkte->setText( "" );
+
+    status = new TextFeld();
+    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        status->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    status->setSchriftFarbe( 0xFF00FF00 );
+    status->setSchriftSize( 12 );
+    status->setSize( 100, 20 );
+    status->setPosition( 300, 0 );
+    status->setText( "lebt" );
+
+    rundenNP = new Array< int >();
+    runde = 0;
+
+    ref = 1;
 }
 
 // Destruktor
 VideoBLTeam::~VideoBLTeam()
 {
-	if( schrift )
-	    schrift->release();
-	rahmen->release();
-	spieler->release();
-	name->release();
-	punkte->release();
-	neuPunkte->release();
-	status->release();
-	rundenNP->release();
+    if( schrift )
+        schrift->release();
+    rahmen->release();
+    spieler->release();
+    name->release();
+    punkte->release();
+    neuPunkte->release();
+    status->release();
+    rundenNP->release();
 }
 
 // nicht constant
 bool VideoBLTeam::addSpieler( VideoSpieler *zSpieler )
 {
-	bool gefunden = 0;
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-		{
-			gefunden = 1;
-			break;
-		}
-	}
-	if( gefunden )
-		return 0;
-	VideoBLSpieler *tmp = new VideoBLSpieler( zSpieler->getSpielerNummer(), zSpieler->getFarbe(), schrift );
-	spieler->set( tmp, spielerAnzahl );
-	spielerAnzahl++;
-	return 1;
+    bool gefunden = 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+        {
+            gefunden = 1;
+            break;
+        }
+    }
+    if( gefunden )
+        return 0;
+    VideoBLSpieler *tmp = new VideoBLSpieler( zSpieler->getSpielerNummer(), zSpieler->getFarbe(), schrift );
+    spieler->set( tmp, spielerAnzahl );
+    spielerAnzahl++;
+    return 1;
 }
 
 bool VideoBLTeam::updateSpielerStatus( VideoSpieler *zSpieler )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-		{
-			spieler->z( i )->updateStatus( zSpieler );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+        {
+            spieler->z( i )->updateStatus( zSpieler );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void VideoBLTeam::setStatus( const char *txt, int f )
 {
-	status->setText( txt );
-	status->setSchriftFarbe( f );
+    status->setText( txt );
+    status->setSchriftFarbe( f );
 }
 
 void VideoBLTeam::setPunkte( int p )
 {
-	this->p = p;
+    this->p = p;
 }
 
 void VideoBLTeam::setMaxPunkte( int mP )
 {
-	this->mP = mP;
+    this->mP = mP;
 }
 
 bool VideoBLTeam::setSpielerPunkte( int sNum, int p )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == sNum )
-		{
-			spieler->z( i )->setPunkte( p );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == sNum )
+        {
+            spieler->z( i )->setPunkte( p );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void VideoBLTeam::addPunkt( bool plus )
 {
-	if( plus )
-		nP++;
-	else
-		nP--;
+    if( plus )
+        nP++;
+    else
+        nP--;
 }
 
 bool VideoBLTeam::addPunkt( int sNum, bool plus )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == sNum )
-		{
-			spieler->z( i )->addPunkt( plus );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == sNum )
+        {
+            spieler->z( i )->addPunkt( plus );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void VideoBLTeam::updatePunkte( bool vorwärts )
 {
-	if( vorwärts )
-	{
-		p += nP;
-		rundenNP->set( nP, runde );
-		nP = 0;
-		runde++;
-	}
-	else
-	{
-		runde--;
-		nP = rundenNP->get( runde );
-		p -= nP;
-	}
-	for( int i = 0; i < spielerAnzahl; i++ )
-		spieler->z( i )->updatePunkte( vorwärts );
+    if( vorwärts )
+    {
+        p += nP;
+        rundenNP->set( nP, runde );
+        nP = 0;
+        runde++;
+    }
+    else
+    {
+        runde--;
+        nP = rundenNP->get( runde );
+        p -= nP;
+    }
+    for( int i = 0; i < spielerAnzahl; i++ )
+        spieler->z( i )->updatePunkte( vorwärts );
 }
 
 void VideoBLTeam::render( int y, Bild &zRObj )
 {
-	rahmen->setSize( 402, 21 + 20 * spielerAnzahl );
-	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	punkte->setText( "" );
-	if( nP == 0 )
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
-	}
-	else if( nP > 0 )
-	{
-		neuPunkte->setText( "+" );
-		neuPunkte->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFF0000 );
-	}
-	punkte->zText()->append( p > 0 ? p : 0 );
-	punkte->zText()->append( "/" );
-	punkte->zText()->append( mP );
-	neuPunkte->zText()->append( nP );
-	rahmen->render( zRObj );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	neuPunkte->render( zRObj );
-	status->render( zRObj );
-	Array< bool > *gemahlt = new Array< bool >();
-	for( int i = 0; i < spielerAnzahl; i++ )
-		gemahlt->set( 0, i );
-	int min = -1;
-	int tmp = -1;
-	for( int h = 0; h < spielerAnzahl; h++ )
-	{
-		min = -1;
-		tmp = -1;
-		for( int i = 0; i < spielerAnzahl; i++ )
-		{
-			if( !spieler->z( i ) )
-				continue;
-			if( gemahlt->hat( i ) && gemahlt->get( i ) )
-				continue;
-			int p = spieler->z( i )->getPunkte();
-			if( p > min )
-			{
-				min = p;
-				tmp = i;
-			}
-		}
-		if( tmp >= 0 )
-		{
-			gemahlt->set( 1, tmp );
-			spieler->z( tmp )->render( 20 + 20 * h, zRObj );
-		}
-		else
-			break;
-	}
-	gemahlt->release();
-	zRObj.releaseDrawOptions();
+    rahmen->setSize( 402, 21 + 20 * spielerAnzahl );
+    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    punkte->setText( "" );
+    if( nP == 0 )
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
+    }
+    else if( nP > 0 )
+    {
+        neuPunkte->setText( "+" );
+        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
+    }
+    punkte->zText()->append( p > 0 ? p : 0 );
+    punkte->zText()->append( "/" );
+    punkte->zText()->append( mP );
+    neuPunkte->zText()->append( nP );
+    rahmen->render( zRObj );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    neuPunkte->render( zRObj );
+    status->render( zRObj );
+    Array< bool > *gemahlt = new Array< bool >();
+    for( int i = 0; i < spielerAnzahl; i++ )
+        gemahlt->set( 0, i );
+    int min = -1;
+    int tmp = -1;
+    for( int h = 0; h < spielerAnzahl; h++ )
+    {
+        min = -1;
+        tmp = -1;
+        for( int i = 0; i < spielerAnzahl; i++ )
+        {
+            if( !spieler->z( i ) )
+                continue;
+            if( gemahlt->hat( i ) && gemahlt->get( i ) )
+                continue;
+            int p = spieler->z( i )->getPunkte();
+            if( p > min )
+            {
+                min = p;
+                tmp = i;
+            }
+        }
+        if( tmp >= 0 )
+        {
+            gemahlt->set( 1, tmp );
+            spieler->z( tmp )->render( 20 + 20 * h, zRObj );
+        }
+        else
+            break;
+    }
+    gemahlt->release();
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int VideoBLTeam::getSpielerAnzahl() const
 {
-	return spielerAnzahl;
+    return spielerAnzahl;
 }
 
 int VideoBLTeam::getPunkte() const
 {
-	return ( p + nP ) < 0 ? 0 : ( p + nP );
+    return ( p + nP ) < 0 ? 0 : ( p + nP );
 }
 
 int VideoBLTeam::getHeight() const
 {
-	return 21 + spielerAnzahl * 20;
+    return 21 + spielerAnzahl * 20;
 }
 
 bool VideoBLTeam::hatGewonnen() const
 {
-	return p + nP >= mP;
+    return p + nP >= mP;
 }
 
 int VideoBLTeam::getSpielerPunkte( int sNum ) const
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == sNum )
-			return spieler->z( i )->getPunkte();
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == sNum )
+            return spieler->z( i )->getPunkte();
+    }
+    return 0;
 }
 
 // Reference Counting
 VideoBLTeam *VideoBLTeam::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 VideoBLTeam *VideoBLTeam::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der VideoBestenliste Klasse aus VideoBestenliste.h
 // Konstruktor
 VideoBestenliste::VideoBestenliste( Schrift *s )
 {
-	rahmen = new LRahmen();
-	rahmen->setRamenBreite( 1 );
-	rahmen->setFarbe( 0xFFFFFFFF );
-	rahmen->setSize( 420, 200 );
-
-	teams = new RCArray< VideoBLTeam >();
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    name->setSchriftZ( s->getThis() );
-	name->setSchriftFarbe( 0xFFFFFFFF );
-	name->setSchriftSize( 12 );
-	name->setText( "Name" );
-	name->setSize( 100, 20 );
-	name->setPosition( 0, 0 );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    punkte->setSchriftZ( s->getThis() );
-	punkte->setSchriftFarbe( 0xFFFFFFFF );
-	punkte->setSchriftSize( 12 );
-	punkte->setText( "Punkte" );
-	punkte->setSize( 100, 20 );
-	punkte->setPosition( 100, 0 );
-
-	neuPunkte = new TextFeld();
-	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    neuPunkte->setSchriftZ( s->getThis() );
-	neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
-	neuPunkte->setSchriftSize( 12 );
-	neuPunkte->setText( "+Punkte" );
-	neuPunkte->setSize( 100, 20 );
-	neuPunkte->setPosition( 200, 0 );
-
-	status = new TextFeld();
-	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	if( s )
-	    status->setSchriftZ( s->getThis() );
-	status->setSchriftFarbe( 0xFFFFFFFF );
-	status->setSchriftSize( 12 );
-	status->setText( "Status" );
-	status->setSize( 100, 20 );
-	status->setPosition( 300, 0 );
-
-	scroll = new VScrollBar();
-	scroll->setKlickScroll( 7 );
-
-	schrift = s;
-	update = 0;
-	teamAnzahl = 0;
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setRamenBreite( 1 );
+    rahmen->setFarbe( 0xFFFFFFFF );
+    rahmen->setSize( 420, 200 );
+
+    teams = new RCArray< VideoBLTeam >();
+
+    name = new TextFeld();
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        name->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    name->setSchriftFarbe( 0xFFFFFFFF );
+    name->setSchriftSize( 12 );
+    name->setText( "Name" );
+    name->setSize( 100, 20 );
+    name->setPosition( 0, 0 );
+
+    punkte = new TextFeld();
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        punkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    punkte->setSchriftFarbe( 0xFFFFFFFF );
+    punkte->setSchriftSize( 12 );
+    punkte->setText( "Punkte" );
+    punkte->setSize( 100, 20 );
+    punkte->setPosition( 100, 0 );
+
+    neuPunkte = new TextFeld();
+    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        neuPunkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
+    neuPunkte->setSchriftSize( 12 );
+    neuPunkte->setText( "+Punkte" );
+    neuPunkte->setSize( 100, 20 );
+    neuPunkte->setPosition( 200, 0 );
+
+    status = new TextFeld();
+    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    if( s )
+        status->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    status->setSchriftFarbe( 0xFFFFFFFF );
+    status->setSchriftSize( 12 );
+    status->setText( "Status" );
+    status->setSize( 100, 20 );
+    status->setPosition( 300, 0 );
+
+    scroll = new VScrollBar();
+    scroll->setKlickScroll( 7 );
+
+    schrift = s;
+    update = 0;
+    teamAnzahl = 0;
+    ref = 1;
 }
 
 // Destruktor
 VideoBestenliste::~VideoBestenliste()
 {
-	rahmen->release();
-	teams->release();
-	name->release();
-	punkte->release();
-	neuPunkte->release();
-	status->release();
-	scroll->release();
-	if( schrift )
-	    schrift->release();
+    rahmen->release();
+    teams->release();
+    name->release();
+    punkte->release();
+    neuPunkte->release();
+    status->release();
+    scroll->release();
+    if( schrift )
+        schrift->release();
 }
 
 // nicht constant
 void VideoBestenliste::setTeamAnzahl( int anz )
 {
-	teamAnzahl = anz;
+    teamAnzahl = anz;
 }
 
 void VideoBestenliste::setTeamStatus( int team, const char *txt, int f )
 {
-	if( teams->z( team ) )
-		teams->z( team )->setStatus( txt, f );
+    if( teams->z( team ) )
+        teams->z( team )->setStatus( txt, f );
 }
 
 void VideoBestenliste::addSpieler( VideoSpieler *zSpieler )
 {
-	int team = zSpieler->getTeam();
-	if( team < 0 )
-		return;
-	if( !teams->z( team ) )
-		teams->set( new VideoBLTeam( team, zSpieler->getTeamFarbe(), schrift ? schrift->getThis() : 0, zSpieler->zTeamName()->getText() ), team );
-	teams->z( team )->addSpieler( zSpieler );
+    int team = zSpieler->getTeam();
+    if( team < 0 )
+        return;
+    if( !teams->z( team ) )
+        teams->set( new VideoBLTeam( team, zSpieler->getTeamFarbe(), schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0, zSpieler->zTeamName()->getText() ), team );
+    teams->z( team )->addSpieler( zSpieler );
 }
 
 void VideoBestenliste::updateSpielerStatus( VideoSpieler *zSpieler )
 {
-	if( teams->z( zSpieler->getTeam() ) )
-		teams->z( zSpieler->getTeam() )->updateSpielerStatus( zSpieler );
+    if( teams->z( zSpieler->getTeam() ) )
+        teams->z( zSpieler->getTeam() )->updateSpielerStatus( zSpieler );
 }
 
 void VideoBestenliste::setTeamPunkte( int teamId, int punkte )
 {
-	if( teams->z( teamId ) )
-		teams->z( teamId )->setPunkte( punkte );
+    if( teams->z( teamId ) )
+        teams->z( teamId )->setPunkte( punkte );
 }
 
 void VideoBestenliste::setTeamMaxPunkte( int teamId, int mPunkte )
 {
-	if( teams->z( teamId ) )
-		teams->z( teamId )->setMaxPunkte( mPunkte );
+    if( teams->z( teamId ) )
+        teams->z( teamId )->setMaxPunkte( mPunkte );
 }
 
 void VideoBestenliste::setSpielerPunkte( int teamNum, int sNum, int punkte )
 {
-	if( teams->z( teamNum ) )
-		teams->z( teamNum )->setSpielerPunkte( sNum, punkte );
+    if( teams->z( teamNum ) )
+        teams->z( teamNum )->setSpielerPunkte( sNum, punkte );
 }
 
 void VideoBestenliste::addPunkt( int tNum, bool plus )
 {
-	if( teams->z( tNum ) )
-		teams->z( tNum )->addPunkt( plus );
+    if( teams->z( tNum ) )
+        teams->z( tNum )->addPunkt( plus );
 }
 
 void VideoBestenliste::addPunkt( int tNum, int sNum, bool plus )
 {
-	if( teams->z( tNum ) )
-		teams->z( tNum )->addPunkt( sNum, plus );
+    if( teams->z( tNum ) )
+        teams->z( tNum )->addPunkt( sNum, plus );
 }
 
 void VideoBestenliste::updatePunkte( bool vorwärts )
 {
-	for( int i = 0; i < teamAnzahl; i++ )
-	{
-		if( teams->z( i ) )
-			teams->z( i )->updatePunkte( vorwärts );
-	}
+    for( int i = 0; i < teamAnzahl; i++ )
+    {
+        if( teams->z( i ) )
+            teams->z( i )->updatePunkte( vorwärts );
+    }
 }
 
 void VideoBestenliste::doPublicMausEreignis( MausEreignis &me )
 {
-	scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
+    scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
 }
 
 void VideoBestenliste::render( Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	rahmen->render( zRObj );
-	zRObj.addScrollOffset( 0, scroll->getScroll() );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	neuPunkte->render( zRObj );
-	status->render( zRObj );
-	int yOff = 20;
-	Array< bool > *gemahlt = new Array< bool >();
-	for( int i = 0; i < teamAnzahl; i++ )
-		gemahlt->set( 0, i );
-	int min = -1;
-	int tmp = -1;
-	for( int h = 0; h < teamAnzahl; h++ )
-	{
-		min = -1;
-		tmp = -1;
-		for( int i = 0; i < teamAnzahl; i++ )
-		{
-			if( !teams->z( i ) )
-				continue;
-			if( gemahlt->hat( i ) && gemahlt->get( i ) )
-				continue;
-			int p = teams->z( i )->getPunkte();
-			if( p > min )
-			{
-				min = p;
-				tmp = i;
-			}
-		}
-		if( tmp >= 0 )
-		{
-			gemahlt->set( 1, tmp );
-			teams->z( tmp )->render( yOff, zRObj );
-			yOff += teams->z( tmp )->getHeight();
-		}
-		else
-			break;
-	}
-	gemahlt->release();
-	zRObj.addScrollOffset( 0, -scroll->getScroll() );
-	scroll->update( yOff, rahmen->getHeight() - 2 );
-	scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
-	zRObj.releaseDrawOptions();
+    if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    rahmen->render( zRObj );
+    zRObj.addScrollOffset( 0, scroll->getScroll() );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    neuPunkte->render( zRObj );
+    status->render( zRObj );
+    int yOff = 20;
+    Array< bool > *gemahlt = new Array< bool >();
+    for( int i = 0; i < teamAnzahl; i++ )
+        gemahlt->set( 0, i );
+    int min = -1;
+    int tmp = -1;
+    for( int h = 0; h < teamAnzahl; h++ )
+    {
+        min = -1;
+        tmp = -1;
+        for( int i = 0; i < teamAnzahl; i++ )
+        {
+            if( !teams->z( i ) )
+                continue;
+            if( gemahlt->hat( i ) && gemahlt->get( i ) )
+                continue;
+            int p = teams->z( i )->getPunkte();
+            if( p > min )
+            {
+                min = p;
+                tmp = i;
+            }
+        }
+        if( tmp >= 0 )
+        {
+            gemahlt->set( 1, tmp );
+            teams->z( tmp )->render( yOff, zRObj );
+            yOff += teams->z( tmp )->getHeight();
+        }
+        else
+            break;
+    }
+    gemahlt->release();
+    zRObj.addScrollOffset( 0, -scroll->getScroll() );
+    scroll->update( yOff, rahmen->getHeight() - 2 );
+    scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int VideoBestenliste::getTeamAnzahl() const
 {
-	return teamAnzahl;
+    return teamAnzahl;
 }
 
 bool VideoBestenliste::teamExistiert( int team ) const
 {
-	return teams->z( team ) != 0;
+    return teams->z( team ) != 0;
 }
 
 int VideoBestenliste::getTeamPunkte( int team ) const
 {
-	return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
+    return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
 }
 
 bool VideoBestenliste::hatTeamGewonnen( int team ) const
 {
-	if( !teams->z( team ) )
-		return 0;
-	return teams->z( team )->hatGewonnen();
+    if( !teams->z( team ) )
+        return 0;
+    return teams->z( team )->hatGewonnen();
 }
 
 int VideoBestenliste::getSpielerPunkte( int team, int sNum ) const
 {
-	if( !teams->z( team ) )
-		return 0;
-	return teams->z( team )->getSpielerPunkte( sNum );
+    if( !teams->z( team ) )
+        return 0;
+    return teams->z( team )->getSpielerPunkte( sNum );
 }
 
 // Reference Counting
 VideoBestenliste *VideoBestenliste::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 VideoBestenliste *VideoBestenliste::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Aufzeichnung/Chat/VideoChat.cpp

@@ -11,81 +11,81 @@
 // Konstruktor
 VideoChat::VideoChat( Schrift *zSchrift )
 {
-	verlauf = new TextFeld();
-	verlauf->setStyle( TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt );
-	verlauf->setRahmenFarbe( 0xFF909090 );
-	verlauf->setRahmenBreite( 1 );
-	verlauf->setText( "" );
-	verlauf->setSchriftFarbe( 0xFFFFFFFF );
-	verlauf->setSchriftSize( 12 );
-	verlauf->setPosition( 20, BildschirmGröße().y - 210 );
-	verlauf->setSize( 450, 200 );
-	verlauf->setSchriftZ( zSchrift->getThis() );
-	ref = 1;
+    verlauf = new TextFeld();
+    verlauf->setStyle( TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt );
+    verlauf->setRahmenFarbe( 0xFF909090 );
+    verlauf->setRahmenBreite( 1 );
+    verlauf->setText( "" );
+    verlauf->setSchriftFarbe( 0xFFFFFFFF );
+    verlauf->setSchriftSize( 12 );
+    verlauf->setPosition( 20, BildschirmGröße().y - 210 );
+    verlauf->setSize( 450, 200 );
+    verlauf->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    ref = 1;
 }
 
 // Destruktor
 VideoChat::~VideoChat()
 {
-	verlauf->release();
+    verlauf->release();
 }
 
 // nicht constant
 void VideoChat::addNachricht( char *nachricht )
 {
-	verlauf->addZeile( nachricht, 0xFFFFFFFF );
-	verlauf->updateVScroll();
+    verlauf->addZeile( nachricht, 0xFFFFFFFF );
+    verlauf->updateVScroll();
 }
 
 void VideoChat::addNachricht( char *nachricht, int farbe )
 {
-	verlauf->addZeile( nachricht, farbe );
-	verlauf->updateVScroll();
+    verlauf->addZeile( nachricht, farbe );
+    verlauf->updateVScroll();
 }
 
 void VideoChat::removeNachricht( char *nachricht )
 {
-	Text *txt = new Text( nachricht );
-	txt->append( "\n" );
-	TextRenderer *textRd = verlauf->zTextRenderer();
-	if( textRd )
-	{
+    Text *txt = new Text( nachricht );
+    txt->append( "\n" );
+    TextRenderer *textRd = verlauf->zTextRenderer();
+    if( textRd )
+    {
         textRd->setSchriftSize( 12 );
         textRd->textFormatieren( txt, verlauf->getBreite() - 15 - 2 );
-	}
-	int n = txt->anzahlVon( '\n' );
-	int n2 = verlauf->zText()->anzahlVon( '\n' );
-	if( n2 > n )
-		verlauf->zText()->remove( verlauf->zText()->positionVon( '\n', n2 - n - 1 ) + 1 );
-	else
-		verlauf->setText( "" );
-	verlauf->updateVScroll();
+    }
+    int n = txt->anzahlVon( '\n' );
+    int n2 = verlauf->zText()->anzahlVon( '\n' );
+    if( n2 > n )
+        verlauf->zText()->remove( verlauf->zText()->positionVon( '\n', n2 - n - 1 ) + 1 );
+    else
+        verlauf->setText( "" );
+    verlauf->updateVScroll();
 }
 
 void VideoChat::doPublicMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	verlauf->doPublicMausEreignis( me );
-	if( !vera && me.verarbeitet )
-	{
-		verlauf->setRahmenFarbe( 0xFFFFFFFF );
-		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
-	}
-	else
-	{
-		verlauf->setRahmenFarbe( 0xFF909090 );
-		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
-	}
+    bool vera = me.verarbeitet;
+    verlauf->doPublicMausEreignis( me );
+    if( !vera && me.verarbeitet )
+    {
+        verlauf->setRahmenFarbe( 0xFFFFFFFF );
+        verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+    }
+    else
+    {
+        verlauf->setRahmenFarbe( 0xFF909090 );
+        verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+    }
 }
 
 void VideoChat::tick( double z )
 {
-	verlauf->tick( z );
+    verlauf->tick( z );
 }
 
 void VideoChat::render( Bild &zRObj )
 {
-	verlauf->render( zRObj );
+    verlauf->render( zRObj );
 }
 
 // constant
@@ -93,14 +93,14 @@ void VideoChat::render( Bild &zRObj )
 // Reference Counting
 VideoChat *VideoChat::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 VideoChat *VideoChat::relese()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Aufzeichnung/Ende/VideoEnde.cpp

@@ -9,62 +9,62 @@
 // Konstruktor
 VideoEnde::VideoEnde( Schrift *zSchrift )
 {
-	text = new TextFeld();
-	text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha );
-	text->removeStyle( TextFeld::Style::Sichtbar );
-	text->setSchriftZ( zSchrift->getThis() );
-	text->setText( "" );
-	text->setSchriftFarbe( 0xFFFFFFFF );
-	text->setSize( 220, 70 );
-	text->setRahmenBreite( 2 );
-	text->setRahmenFarbe( 0xFFFFFFFF );
-	text->setHintergrundFarbe( 0xA0000000 );
-	ref = 1;
+    text = new TextFeld();
+    text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha );
+    text->removeStyle( TextFeld::Style::Sichtbar );
+    text->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    text->setText( "" );
+    text->setSchriftFarbe( 0xFFFFFFFF );
+    text->setSize( 220, 70 );
+    text->setRahmenBreite( 2 );
+    text->setRahmenFarbe( 0xFFFFFFFF );
+    text->setHintergrundFarbe( 0xA0000000 );
+    ref = 1;
 }
 
 // Destruktor
 VideoEnde::~VideoEnde()
 {
-	text->release();
+    text->release();
 }
 
 // nicht constant
 void VideoEnde::setSichtbar( bool b )
 {
-	text->setStyle( TextFeld::Style::Sichtbar, b );
+    text->setStyle( TextFeld::Style::Sichtbar, b );
 }
 
 void VideoEnde::setText( const char *txt )
 {
-	text->zTextRenderer()->setSchriftSize( 12 );
-	Text t = txt;
-	text->setSize( 10 + text->zTextRenderer()->getTextBreite( t ), 10 + text->zTextRenderer()->getTextHeight( t ) );
-	text->setText( txt );
+    text->zTextRenderer()->setSchriftSize( 12 );
+    Text t = txt;
+    text->setSize( 10 + text->zTextRenderer()->getTextBreite( t ), 10 + text->zTextRenderer()->getTextHeight( t ) );
+    text->setText( txt );
 }
 
 void VideoEnde::render( Bild &zRObj )
 {
-	text->setPosition( zRObj.getBreite() / 2 - text->getBreite() / 2, zRObj.getHeight() / 2 - text->getHeight() / 2 );
-	text->render( zRObj );
+    text->setPosition( zRObj.getBreite() / 2 - text->getBreite() / 2, zRObj.getHeight() / 2 - text->getHeight() / 2 );
+    text->render( zRObj );
 }
 
 // constant
 bool VideoEnde::istSichtbar() const
 {
-	return text->hatStyle( TextFeld::Style::Sichtbar );
+    return text->hatStyle( TextFeld::Style::Sichtbar );
 }
 
 // Reference Counting
 VideoEnde *VideoEnde::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 VideoEnde *VideoEnde::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Aufzeichnung/Nachricht/VideoNachricht.cpp

@@ -4,176 +4,176 @@
 // Konstruktor
 RundeNachricht::RundeNachricht( Datei *d, int spielerAnzahl )
 {
-	index = 0;
-	maxNachricht = 0;
-	nachrichten = new Array< VideoMSG* >();
-	vDat = d;
-	rvd = new RundeVideoDaten();
-	rsvd = new Array< RundeSpielerVideoDaten* >();
-	aktiv = 1;
-	ref = 1;
-	vDat->lese( (char*)&rvd->mapBreite, 4 );
-	vDat->lese( (char*)&rvd->mapHöhe, 4 );
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		RundeSpielerVideoDaten *svd = new RundeSpielerVideoDaten();
-		vDat->lese( (char*)&svd->wendigkeit, 8 );
-		vDat->lese( (char*)&svd->xPos, 8 );
-		vDat->lese( (char*)&svd->yPos, 8 );
-		vDat->lese( (char*)&svd->xSpeed, 8 );
-		vDat->lese( (char*)&svd->ySpeed, 8 );
-		rsvd->set( svd, i );
-	}
+    index = 0;
+    maxNachricht = 0;
+    nachrichten = new Array< VideoMSG * >();
+    vDat = d;
+    rvd = new RundeVideoDaten();
+    rsvd = new Array< RundeSpielerVideoDaten * >();
+    aktiv = 1;
+    ref = 1;
+    vDat->lese( (char *)&rvd->mapBreite, 4 );
+    vDat->lese( (char *)&rvd->mapHöhe, 4 );
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        RundeSpielerVideoDaten *svd = new RundeSpielerVideoDaten();
+        vDat->lese( (char *)&svd->wendigkeit, 8 );
+        vDat->lese( (char *)&svd->xPos, 8 );
+        vDat->lese( (char *)&svd->yPos, 8 );
+        vDat->lese( (char *)&svd->xSpeed, 8 );
+        vDat->lese( (char *)&svd->ySpeed, 8 );
+        rsvd->set( svd, i );
+    }
 }
 
 // Destruktor
 RundeNachricht::~RundeNachricht()
 {
-	for( int i = 0; i < maxNachricht; i++ )
-	{
-		VideoMSG *tmp = nachrichten->get( i );
-		if( !tmp->typ )
-			delete (VideoMSG*)tmp;
-		else
-		{
-			if( ( (VideoAktionMSG*)tmp )->aktion == 4 )
-				delete (VideoChatMSG*)tmp;
-			else if( ( (VideoAktionMSG*)tmp )->aktion == 5 )
-				delete (VideoLinieMSG*)tmp;
-			else
-				delete (VideoAktionMSG*)tmp;
-		}
-	}
-	nachrichten->release();
-	vDat->release();
-	delete rvd;
-	int anz = rsvd->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-		delete rsvd->get( i );
-	rsvd->release();
+    for( int i = 0; i < maxNachricht; i++ )
+    {
+        VideoMSG *tmp = nachrichten->get( i );
+        if( !tmp->typ )
+            delete (VideoMSG *)tmp;
+        else
+        {
+            if( ( (VideoAktionMSG *)tmp )->aktion == 4 )
+                delete (VideoChatMSG *)tmp;
+            else if( ( (VideoAktionMSG *)tmp )->aktion == 5 )
+                delete (VideoLinieMSG *)tmp;
+            else
+                delete (VideoAktionMSG *)tmp;
+        }
+    }
+    nachrichten->release();
+    vDat->release();
+    delete rvd;
+    int anz = rsvd->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+        delete rsvd->get( i );
+    rsvd->release();
 }
 
 // nicht constant
 VideoMSG *RundeNachricht::GetNextNachricht()
 {
-	if( index < maxNachricht )
-	{
-		index++;
-		return nachrichten->get( index - 1 );
-	}
-	else if( aktiv )
-	{
-		char typ = 0;
-		vDat->lese( &typ, 1 );
-		if( !typ )
-		{
-			VideoMSG *vtmsg = new VideoMSG();
-			vtmsg->typ = typ;
-			nachrichten->set( vtmsg, index );
-			index++;
-			maxNachricht++;
-			return vtmsg;
-		}
-		else if( typ == 1 )
-		{
-			NachrichtVideoDaten nvd;
-			vDat->lese( (char*)&nvd.spielerNummer, 4 );
-			vDat->lese( (char*)&nvd.län, 2 );
-			char *bytes = new char[ nvd.län ];
-			vDat->lese( bytes, nvd.län );
-			if( bytes[ 0 ] >= 0 && bytes[ 0 ] <= 3 )
-			{
-				VideoAktionMSG *vamsg = new VideoAktionMSG();
-				vamsg->typ = typ;
-				vamsg->spielerNummer = nvd.spielerNummer;
-				vamsg->aktion = bytes[ 0 ];
-				nachrichten->set( vamsg, index );
-				index++;
-				maxNachricht++;
-				delete[] bytes;
-				return vamsg;
-			}
-			if( bytes[ 0 ] == 4 )
-			{
-				VideoChatMSG *vcmsg = new VideoChatMSG();
-				vcmsg->typ = typ;
-				vcmsg->spielerNummer = nvd.spielerNummer;
-				vcmsg->aktion = bytes[ 0 ];
-				vcmsg->län = nvd.län - 1;
-				vcmsg->msg.setText( bytes + 1, vcmsg->län );
-				nachrichten->set( vcmsg, index );
-				index++;
-				maxNachricht++;
-				delete[] bytes;
-				return vcmsg;
-			}
-			if( bytes[ 0 ] == 5 )
-			{
-				VideoLinieMSG *vlmsg = new VideoLinieMSG();
-				vlmsg->typ = typ;
-				vlmsg->spielerNummer = nvd.spielerNummer;
-				vlmsg->aktion = bytes[ 0 ];
-				vlmsg->unterbrechung = *( bytes + 1 );
-				nachrichten->set( vlmsg, index );
-				index++;
-				maxNachricht++;
-				delete[] bytes;
-				return vlmsg;
-			}
-			delete[] bytes;
-		}
-		else
-		{
-			VideoMSG *msg = new VideoMSG();
-			msg->typ = typ;
-			nachrichten->set( msg, index );
-			index++;
-			maxNachricht++;
-			return msg;
-		}
-	}
-	return 0;
+    if( index < maxNachricht )
+    {
+        index++;
+        return nachrichten->get( index - 1 );
+    }
+    else if( aktiv )
+    {
+        char typ = 0;
+        vDat->lese( &typ, 1 );
+        if( !typ )
+        {
+            VideoMSG *vtmsg = new VideoMSG();
+            vtmsg->typ = typ;
+            nachrichten->set( vtmsg, index );
+            index++;
+            maxNachricht++;
+            return vtmsg;
+        }
+        else if( typ == 1 )
+        {
+            NachrichtVideoDaten nvd;
+            vDat->lese( (char *)&nvd.spielerNummer, 4 );
+            vDat->lese( (char *)&nvd.län, 2 );
+            char *bytes = new char[ nvd.län ];
+            vDat->lese( bytes, nvd.län );
+            if( bytes[ 0 ] >= 0 && bytes[ 0 ] <= 3 )
+            {
+                VideoAktionMSG *vamsg = new VideoAktionMSG();
+                vamsg->typ = typ;
+                vamsg->spielerNummer = nvd.spielerNummer;
+                vamsg->aktion = bytes[ 0 ];
+                nachrichten->set( vamsg, index );
+                index++;
+                maxNachricht++;
+                delete[] bytes;
+                return vamsg;
+            }
+            if( bytes[ 0 ] == 4 )
+            {
+                VideoChatMSG *vcmsg = new VideoChatMSG();
+                vcmsg->typ = typ;
+                vcmsg->spielerNummer = nvd.spielerNummer;
+                vcmsg->aktion = bytes[ 0 ];
+                vcmsg->län = nvd.län - 1;
+                vcmsg->msg.setText( bytes + 1, vcmsg->län );
+                nachrichten->set( vcmsg, index );
+                index++;
+                maxNachricht++;
+                delete[] bytes;
+                return vcmsg;
+            }
+            if( bytes[ 0 ] == 5 )
+            {
+                VideoLinieMSG *vlmsg = new VideoLinieMSG();
+                vlmsg->typ = typ;
+                vlmsg->spielerNummer = nvd.spielerNummer;
+                vlmsg->aktion = bytes[ 0 ];
+                vlmsg->unterbrechung = *( bytes + 1 );
+                nachrichten->set( vlmsg, index );
+                index++;
+                maxNachricht++;
+                delete[] bytes;
+                return vlmsg;
+            }
+            delete[] bytes;
+        }
+        else
+        {
+            VideoMSG *msg = new VideoMSG();
+            msg->typ = typ;
+            nachrichten->set( msg, index );
+            index++;
+            maxNachricht++;
+            return msg;
+        }
+    }
+    return 0;
 }
 
 VideoMSG *RundeNachricht::GetLastNachricht()
 {
-	if( index == 0 )
-		return 0;
-	index--;
-	return nachrichten->get( index );
+    if( index == 0 )
+        return 0;
+    index--;
+    return nachrichten->get( index );
 }
 
 void RundeNachricht::setEnde()
 {
-	aktiv = 0;
+    aktiv = 0;
 }
 
 // constant
 RundeVideoDaten *RundeNachricht::getRVD() const
 {
-	return rvd;
+    return rvd;
 }
 
 RundeSpielerVideoDaten *RundeNachricht::getRSVD( int index ) const
 {
-	if( !rsvd->hat( index ) )
-		return 0;
-	return rsvd->get( index );
+    if( !rsvd->hat( index ) )
+        return 0;
+    return rsvd->get( index );
 }
 
 // Reference Counting
 RundeNachricht *RundeNachricht::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 RundeNachricht *RundeNachricht::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
@@ -181,186 +181,186 @@ RundeNachricht *RundeNachricht::release()
 // Konatruktor
 SpielNachricht::SpielNachricht( int num )
 {
-	runde = 0;
-	maxRunde = 0;
-	teamAnzahl = 0;
-	runden = new RCArray< RundeNachricht >();
-	vDat = new Datei();
-	svd = new SpielVideoDaten();
-	spvd = new Array< SpielerVideoDaten* >();
-	tvd = new Array< TeamVideoDaten* >();
-	error = 0;
-	fehler = new Text();
-	ref = 1;
-	Text pfad( "data/tmp/historie/" );
-	pfad += num;
-	pfad += "/verlauf.ksggl";
-	vDat->setDatei( pfad );
-	if( !vDat->open( Datei::Style::lesen ) )
-	{
-		*fehler = "Die Videodatei '";
-		*fehler += pfad;
-		*fehler += "' konnte nicht geöffnet werden.\nEs existiert eventuell keine Aufzeichnung von diesem Spiel.";
-		error = 1;
-	}
-	Array< int > team;
-	if( !error )
-	{
-		vDat->lese( (char*)&svd->spielerAnzahl, 4 );
-		for( int i = 0; i < svd->spielerAnzahl; i++ )
-		{
-			SpielerVideoDaten *svd = new SpielerVideoDaten();
-			vDat->lese( (char*)&svd->index, 4 );
-			vDat->lese( (char*)&svd->spielerNummer, 4 );
-			vDat->lese( (char*)&svd->kamBreite, 4 );
-			vDat->lese( (char*)&svd->kamHöhe, 4 );
-			vDat->lese( (char*)&svd->team, 4 );
-			vDat->lese( (char*)&svd->spielerFarbe, 4 );
-			vDat->lese( (char*)&svd->teamFarbe, 4 );
-			char län = 0;
-			vDat->lese( &län, 1 );
-			char *n = new char[ län + 1 ];
-			n[ län ] = 0;
-			if( län )
-				vDat->lese( n, län );
-			svd->name.setText( n );
-			delete[] n;
-			vDat->lese( &län, 1 );
-			n = new char[ län + 1 ];
-			n[ län ] = 0;
-			if( län )
-				vDat->lese( n, län );
-			svd->teamName.setText( n );
-			delete[] n;
-			spvd->set( svd, svd->index );
-			if( team.getWertIndex( svd->team ) < 0 )
-			{
-				team.set( svd->team, teamAnzahl );
-				teamAnzahl++;
-			}
-		}
-		for( int i = 0; i < teamAnzahl; i++ )
-		{
-			TeamVideoDaten *t = new TeamVideoDaten();
-			vDat->lese( (char*)&t->teamNummer, 4 );
-			vDat->lese( (char*)&t->maxPunkte, 4 );
-			vDat->lese( (char*)&t->punkte, 4 );
-			tvd->set( t, i );
-		}
-		RundeNachricht *r = new RundeNachricht( vDat->getThis(), svd->spielerAnzahl );
-		runden->set( r, runde );
-	}
+    runde = 0;
+    maxRunde = 0;
+    teamAnzahl = 0;
+    runden = new RCArray< RundeNachricht >();
+    vDat = new Datei();
+    svd = new SpielVideoDaten();
+    spvd = new Array< SpielerVideoDaten * >();
+    tvd = new Array< TeamVideoDaten * >();
+    error = 0;
+    fehler = new Text();
+    ref = 1;
+    Text pfad( "data/tmp/historie/" );
+    pfad += num;
+    pfad += "/verlauf.ksggl";
+    vDat->setDatei( pfad );
+    if( !vDat->open( Datei::Style::lesen ) )
+    {
+        *fehler = "Die Videodatei '";
+        *fehler += pfad;
+        *fehler += "' konnte nicht geöffnet werden.\nEs existiert eventuell keine Aufzeichnung von diesem Spiel.";
+        error = 1;
+    }
+    Array< int > team;
+    if( !error )
+    {
+        vDat->lese( (char *)&svd->spielerAnzahl, 4 );
+        for( int i = 0; i < svd->spielerAnzahl; i++ )
+        {
+            SpielerVideoDaten *svd = new SpielerVideoDaten();
+            vDat->lese( (char *)&svd->index, 4 );
+            vDat->lese( (char *)&svd->spielerNummer, 4 );
+            vDat->lese( (char *)&svd->kamBreite, 4 );
+            vDat->lese( (char *)&svd->kamHöhe, 4 );
+            vDat->lese( (char *)&svd->team, 4 );
+            vDat->lese( (char *)&svd->spielerFarbe, 4 );
+            vDat->lese( (char *)&svd->teamFarbe, 4 );
+            char län = 0;
+            vDat->lese( &län, 1 );
+            char *n = new char[ län + 1 ];
+            n[ län ] = 0;
+            if( län )
+                vDat->lese( n, län );
+            svd->name.setText( n );
+            delete[] n;
+            vDat->lese( &län, 1 );
+            n = new char[ län + 1 ];
+            n[ län ] = 0;
+            if( län )
+                vDat->lese( n, län );
+            svd->teamName.setText( n );
+            delete[] n;
+            spvd->set( svd, svd->index );
+            if( team.getWertIndex( svd->team ) < 0 )
+            {
+                team.set( svd->team, teamAnzahl );
+                teamAnzahl++;
+            }
+        }
+        for( int i = 0; i < teamAnzahl; i++ )
+        {
+            TeamVideoDaten *t = new TeamVideoDaten();
+            vDat->lese( (char *)&t->teamNummer, 4 );
+            vDat->lese( (char *)&t->maxPunkte, 4 );
+            vDat->lese( (char *)&t->punkte, 4 );
+            tvd->set( t, i );
+        }
+        RundeNachricht *r = new RundeNachricht( dynamic_cast<Datei *>( vDat->getThis() ), svd->spielerAnzahl );
+        runden->set( r, runde );
+    }
 }
 
 // Destruktor
 SpielNachricht::~SpielNachricht()
 {
-	runden->release();
-	vDat->close();
-	vDat->release();
-	for( int i = 0; i < svd->spielerAnzahl; i++ )
-		delete spvd->get( i );
-	delete svd;
-	spvd->release();
-	for( int i = 0; i < teamAnzahl; i++ )
-		delete tvd->get( i );
-	tvd->release();
-	fehler->release();
+    runden->release();
+    vDat->close();
+    vDat->release();
+    for( int i = 0; i < svd->spielerAnzahl; i++ )
+        delete spvd->get( i );
+    delete svd;
+    spvd->release();
+    for( int i = 0; i < teamAnzahl; i++ )
+        delete tvd->get( i );
+    tvd->release();
+    fehler->release();
 }
 
 // nicht constant
 VideoMSG *SpielNachricht::GetNextNachricht()
 {
-	return runden->z( runde )->GetNextNachricht();
+    return runden->z( runde )->GetNextNachricht();
 }
 
 VideoMSG *SpielNachricht::GetLastNachricht()
 {
-	return runden->z( runde )->GetLastNachricht();
+    return runden->z( runde )->GetLastNachricht();
 }
 
 int SpielNachricht::setRundenEnde( bool vorwärts )
 {
-	if( vorwärts )
-	{
-		if( runde < maxRunde )
-			runde++;
-		else
-		{
-			runden->z( runde )->setEnde();
-			runde++;
-			maxRunde++;
-			RundeNachricht *tmp = new RundeNachricht( vDat->getThis(), svd->spielerAnzahl );
-			runden->set( tmp, runde );
-		}
-	}
-	else
-		runde--;
-	if( runde < 0 )
-	{
-		runde = 0;
-		return -1;
-	}
-	return runde;
+    if( vorwärts )
+    {
+        if( runde < maxRunde )
+            runde++;
+        else
+        {
+            runden->z( runde )->setEnde();
+            runde++;
+            maxRunde++;
+            RundeNachricht *tmp = new RundeNachricht( dynamic_cast<Datei *>( vDat->getThis() ), svd->spielerAnzahl );
+            runden->set( tmp, runde );
+        }
+    }
+    else
+        runde--;
+    if( runde < 0 )
+    {
+        runde = 0;
+        return -1;
+    }
+    return runde;
 }
 
 // constant
 SpielVideoDaten *SpielNachricht::getSVD() const
 {
-	return svd;
+    return svd;
 }
 
 SpielerVideoDaten *SpielNachricht::getSPVD( int index ) const
 {
-	if( !spvd->hat( index ) )
-		return 0;
-	return spvd->get( index );
+    if( !spvd->hat( index ) )
+        return 0;
+    return spvd->get( index );
 }
 
 TeamVideoDaten *SpielNachricht::getTVD( int index ) const
 {
-	if( !tvd->hat( index ) )
-		return 0;
-	return tvd->get( index );
+    if( !tvd->hat( index ) )
+        return 0;
+    return tvd->get( index );
 }
 
 RundeVideoDaten *SpielNachricht::getRVD() const
 {
-	return runden->z( runde )->getRVD();
+    return runden->z( runde )->getRVD();
 }
 
 RundeSpielerVideoDaten *SpielNachricht::getRSVD( int index ) const
 {
-	return runden->z( runde )->getRSVD( index );
+    return runden->z( runde )->getRSVD( index );
 }
 
 bool SpielNachricht::hatFehler( Text *txt ) const
 {
-	txt->setText( fehler->getText() );
-	return error;
+    txt->setText( fehler->getText() );
+    return error;
 }
 
 int SpielNachricht::getTeamAnzahl() const
 {
-	return teamAnzahl;
+    return teamAnzahl;
 }
 
 int SpielNachricht::getRunde() const
 {
-	return runde;
+    return runde;
 }
 
 // Reference Counting
 SpielNachricht *SpielNachricht::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 SpielNachricht *SpielNachricht::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Aufzeichnung/Spieler/VideoSpieler.cpp

@@ -8,378 +8,378 @@
 // Konstruktor
 VideoSpieler::VideoSpieler( SpielerVideoDaten *vDaten )
 {
-	spielerNummer = vDaten->spielerNummer;
-	team = vDaten->team;
-	spielerFarbe = 0;
-	teamFarbe = 0;
-	daten = new Array< VideoSpielerRundeDaten* >();
-	daten->set( new VideoSpielerRundeDaten( { 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 } ), 0 );
-	runde = -1;
-	name = new Text();
-	teamName = new Text();
-	teamRahmen = new LRahmen();
-	teamRahmen->setRamenBreite( 1 );
-	teamRahmen->setSize( 10, 10 );
-	ref = 1;
-	spielerFarbe = vDaten->spielerFarbe;
-	teamFarbe = vDaten->teamFarbe;
-	name->setText( vDaten->name.getText() );
-	teamName->setText( vDaten->teamName.getText() );
-	teamRahmen->setFarbe( vDaten->teamFarbe );
-	gewonneneRunden = 0;
-	linienLänge = 0;
-	zeitAmLeben = 0;
-	zeitTod = 0;
-	kills = 0;
-	tode = 0;
-	killFarbe = 0;
+    spielerNummer = vDaten->spielerNummer;
+    team = vDaten->team;
+    spielerFarbe = 0;
+    teamFarbe = 0;
+    daten = new Array< VideoSpielerRundeDaten * >();
+    daten->set( new VideoSpielerRundeDaten( { 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 } ), 0 );
+    runde = -1;
+    name = new Text();
+    teamName = new Text();
+    teamRahmen = new LRahmen();
+    teamRahmen->setRamenBreite( 1 );
+    teamRahmen->setSize( 10, 10 );
+    ref = 1;
+    spielerFarbe = vDaten->spielerFarbe;
+    teamFarbe = vDaten->teamFarbe;
+    name->setText( vDaten->name.getText() );
+    teamName->setText( vDaten->teamName.getText() );
+    teamRahmen->setFarbe( vDaten->teamFarbe );
+    gewonneneRunden = 0;
+    linienLänge = 0;
+    zeitAmLeben = 0;
+    zeitTod = 0;
+    kills = 0;
+    tode = 0;
+    killFarbe = 0;
 }
 
 // Destruktor
 VideoSpieler::~VideoSpieler()
 {
-	teamRahmen->release();
-	name->release();
-	teamName->release();
-	int anz = daten->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( daten->hat( i ) )
-			delete daten->get( i );
-	}
-	daten->release();
+    teamRahmen->release();
+    name->release();
+    teamName->release();
+    int anz = daten->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( daten->hat( i ) )
+            delete daten->get( i );
+    }
+    daten->release();
 }
 
 // nicht constant
 void VideoSpieler::addKill()
 {
-	kills++;
-	rKills.set( rKills.get( runde ) + 1, runde );
+    kills++;
+    rKills.set( rKills.get( runde ) + 1, runde );
 }
 
 void VideoSpieler::neuRunde( bool vorwärts, RundeSpielerVideoDaten *vDaten, bool amLeben )
 {
-	if( vorwärts )
-	{
-		if( runde >= 0 )
-		{
-			if( daten->get( runde )->amLeben )
-				gewonneneRunden++;
-		}
-		runde++;
-		rLinienLänge.set( 0, runde );
-		rKills.set( 0, runde );
-		rTodesZeit.set( 0, runde );
-		if( daten->hat( runde ) )
-			delete daten->get( runde );
-		daten->set( new VideoSpielerRundeDaten( { vDaten->xPos, vDaten->yPos, vDaten->xSpeed,
-												  vDaten->ySpeed, vDaten->wendigkeit, 1, amLeben, 0, 0, 1, 0, 0 } ), runde );
-	}
-	else
-		runde--;
+    if( vorwärts )
+    {
+        if( runde >= 0 )
+        {
+            if( daten->get( runde )->amLeben )
+                gewonneneRunden++;
+        }
+        runde++;
+        rLinienLänge.set( 0, runde );
+        rKills.set( 0, runde );
+        rTodesZeit.set( 0, runde );
+        if( daten->hat( runde ) )
+            delete daten->get( runde );
+        daten->set( new VideoSpielerRundeDaten( { vDaten->xPos, vDaten->yPos, vDaten->xSpeed,
+                                                  vDaten->ySpeed, vDaten->wendigkeit, 1, amLeben, 0, 0, 1, 0, 0 } ), runde );
+    }
+    else
+        runde--;
 }
 
 void VideoSpieler::setLinksKurve( bool lKurve )
 {
-	daten->get( runde )->lKurve = lKurve;
+    daten->get( runde )->lKurve = lKurve;
 }
 
 void VideoSpieler::setRechtsKurve( bool rKurve )
 {
-	daten->get( runde )->rKurve = rKurve;
+    daten->get( runde )->rKurve = rKurve;
 }
 
 void VideoSpieler::setLinienUnterbrechung( bool unterbrechung )
 {
-	daten->get( runde )->linieUnterbrochen = unterbrechung;
+    daten->get( runde )->linieUnterbrochen = unterbrechung;
 }
 
 void VideoSpieler::prozessKurve( double zeit )
 {
-	VideoSpielerRundeDaten *dat = daten->get( runde );
-	if( dat->amLeben )
-	{
-		if( dat->lKurve || dat->rKurve )
-		{
-			double grad = dat->kurve * zeit;
-			if( dat->lKurve )
-				grad = -grad;
-			double cs = cos( grad );
-			double sn = sin( grad );
-			double tmpX = ( dat->xSpeed * cs - dat->ySpeed * sn );
-			double tmpY = ( dat->xSpeed * sn + dat->ySpeed * cs );
-			dat->xSpeed = tmpX;
-			dat->ySpeed = tmpY;
-		}
-	}
+    VideoSpielerRundeDaten *dat = daten->get( runde );
+    if( dat->amLeben )
+    {
+        if( dat->lKurve || dat->rKurve )
+        {
+            double grad = dat->kurve * zeit;
+            if( dat->lKurve )
+                grad = -grad;
+            double cs = cos( grad );
+            double sn = sin( grad );
+            double tmpX = ( dat->xSpeed * cs - dat->ySpeed * sn );
+            double tmpY = ( dat->xSpeed * sn + dat->ySpeed * cs );
+            dat->xSpeed = tmpX;
+            dat->ySpeed = tmpY;
+        }
+    }
 }
 
 void VideoSpieler::tick( Bild *zMap, double zeit )
 {
-	VideoSpielerRundeDaten *dat = daten->get( runde );
-	dat->spielZeit += zeit;
-	bool wiederbelebt = 0;
-	bool rückwärts = zeit < 0;
-	if( rückwärts && !dat->amLeben )
-	{
-		if( dat->todesZeit >= dat->spielZeit )
-		{
-			dat->amLeben = 1;
-			wiederbelebt = 1;
-		}
-	}
-	if( dat->amLeben )
-	{
-		zeitAmLeben += zeit;
-		if( !rückwärts )
-			prozessKurve( zeit );
-		int dpx = 0;
-		int dpy = 0;
-		int dgx = zMap->getBreite();
-		int dgy = zMap->getHeight();
-		int *buff = zMap->getBuffer();
-		if( zMap && !dat->linieUnterbrochen )
-		{
-			int x1 = (int)( dat->xPos + 0.5 );
-			int y1 = (int)( dat->yPos + 0.5 );
-			int x2 = (int)( dat->xPos + dat->xSpeed * zeit + 0.5 );
-			int y2 = (int)( dat->yPos + dat->ySpeed * zeit + 0.5 );
-			int xlän = x2 - x1, axlän = abs( xlän );
-			int ylän = y2 - y1, aylän = abs( ylän );
-			double xf = (double)xlän / ( aylän ? aylän : 1 );
-			double yf = (double)ylän / ( axlän ? axlän : 1 );
-			if( axlän > aylän )
-				xf = xf < 0 ? -1 : 1;
-			else
-				yf = yf < 0 ? -1 : 1;
-			double x = (double)x1, y = (double)y1;
-			int maxP = (int)( sqrt( (double)( xlän * xlän + ylän * ylän ) ) + 0.5 );
-			int count = 0;
-			int lastX = (int)( x + 0.5 ), lastY = (int)( y + 0.5 );
-			if( !rückwärts )
-			{
-				while( !( (int)( x + 0.5 ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
-				{
-					if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
-					{
-						killFarbe = 0;
-						tode++;
-						dat->todesZeit = dat->spielZeit;
-						rTodesZeit.set( (int)dat->spielZeit, runde );
-						dat->amLeben = 0;
-						dat->renderVorTod = count;
-						break;
-					}
-					if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] )
-					{
-						if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] != spielerFarbe )
-							killFarbe = buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ];
-						else
-							killFarbe = 0;
-						tode++;
-						dat->todesZeit = dat->spielZeit;
-						rTodesZeit.set( (int)dat->spielZeit, runde );
-						dat->amLeben = 0;
-						dat->renderVorTod = count;
-						break;
-					}
-					buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
-					linienLänge++;
-					rLinienLänge.set( rLinienLänge.get( runde ) + 1, runde );
-					x += xf, y += yf;
-					if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
-					{
-						if( (int)xf )
-						{
-							if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
-							    buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
-						}
-						else
-						{
-							if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
-								buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = spielerFarbe;
-						}
-					}
-					lastX = (int)( x + 0.5 );
-					lastY = (int)( y + 0.5 );
-					count++;
-				}
-			}
-			if( rückwärts )
-			{
-				if( wiederbelebt )
-					maxP = dat->renderVorTod;
-				while( !( (int)( x ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
-				{
-					count++;
-					x += xf, y += yf;
-					if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
-					{
-						if( (int)xf )
-						{
-							if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
-								buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = 0;
-						}
-						else
-						{
-							if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
-								buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
-						}
-					}
-					lastX = (int)( x + 0.5 );
-					lastY = (int)( y + 0.5 );
-					if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
-						buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
-				}
-			}
-		}
-		dat->xPos += dat->xSpeed * zeit;
-		dat->yPos += dat->ySpeed * zeit;
-		if( rückwärts )
-			prozessKurve( zeit );
-	}
-	else
-		zeitTod += zeit;
+    VideoSpielerRundeDaten *dat = daten->get( runde );
+    dat->spielZeit += zeit;
+    bool wiederbelebt = 0;
+    bool rückwärts = zeit < 0;
+    if( rückwärts && !dat->amLeben )
+    {
+        if( dat->todesZeit >= dat->spielZeit )
+        {
+            dat->amLeben = 1;
+            wiederbelebt = 1;
+        }
+    }
+    if( dat->amLeben )
+    {
+        zeitAmLeben += zeit;
+        if( !rückwärts )
+            prozessKurve( zeit );
+        int dpx = 0;
+        int dpy = 0;
+        int dgx = zMap->getBreite();
+        int dgy = zMap->getHeight();
+        int *buff = zMap->getBuffer();
+        if( zMap && !dat->linieUnterbrochen )
+        {
+            int x1 = (int)( dat->xPos + 0.5 );
+            int y1 = (int)( dat->yPos + 0.5 );
+            int x2 = (int)( dat->xPos + dat->xSpeed * zeit + 0.5 );
+            int y2 = (int)( dat->yPos + dat->ySpeed * zeit + 0.5 );
+            int xlän = x2 - x1, axlän = abs( xlän );
+            int ylän = y2 - y1, aylän = abs( ylän );
+            double xf = (double)xlän / ( aylän ? aylän : 1 );
+            double yf = (double)ylän / ( axlän ? axlän : 1 );
+            if( axlän > aylän )
+                xf = xf < 0 ? -1 : 1;
+            else
+                yf = yf < 0 ? -1 : 1;
+            double x = (double)x1, y = (double)y1;
+            int maxP = (int)( sqrt( (double)( xlän * xlän + ylän * ylän ) ) + 0.5 );
+            int count = 0;
+            int lastX = (int)( x + 0.5 ), lastY = (int)( y + 0.5 );
+            if( !rückwärts )
+            {
+                while( !( (int)( x + 0.5 ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
+                {
+                    if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
+                    {
+                        killFarbe = 0;
+                        tode++;
+                        dat->todesZeit = dat->spielZeit;
+                        rTodesZeit.set( (int)dat->spielZeit, runde );
+                        dat->amLeben = 0;
+                        dat->renderVorTod = count;
+                        break;
+                    }
+                    if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] )
+                    {
+                        if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] != spielerFarbe )
+                            killFarbe = buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ];
+                        else
+                            killFarbe = 0;
+                        tode++;
+                        dat->todesZeit = dat->spielZeit;
+                        rTodesZeit.set( (int)dat->spielZeit, runde );
+                        dat->amLeben = 0;
+                        dat->renderVorTod = count;
+                        break;
+                    }
+                    buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
+                    linienLänge++;
+                    rLinienLänge.set( rLinienLänge.get( runde ) + 1, runde );
+                    x += xf, y += yf;
+                    if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
+                    {
+                        if( (int)xf )
+                        {
+                            if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
+                                buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
+                        }
+                        else
+                        {
+                            if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
+                                buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = spielerFarbe;
+                        }
+                    }
+                    lastX = (int)( x + 0.5 );
+                    lastY = (int)( y + 0.5 );
+                    count++;
+                }
+            }
+            if( rückwärts )
+            {
+                if( wiederbelebt )
+                    maxP = dat->renderVorTod;
+                while( !( (int)( x ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
+                {
+                    count++;
+                    x += xf, y += yf;
+                    if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
+                    {
+                        if( (int)xf )
+                        {
+                            if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
+                                buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = 0;
+                        }
+                        else
+                        {
+                            if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
+                                buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
+                        }
+                    }
+                    lastX = (int)( x + 0.5 );
+                    lastY = (int)( y + 0.5 );
+                    if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
+                        buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
+                }
+            }
+        }
+        dat->xPos += dat->xSpeed * zeit;
+        dat->yPos += dat->ySpeed * zeit;
+        if( rückwärts )
+            prozessKurve( zeit );
+    }
+    else
+        zeitTod += zeit;
 }
 
 void VideoSpieler::render( VideoKamera *zKam, Bild &zRObj )
 {
-	VideoSpielerRundeDaten *dat = daten->get( runde );
-	if( dat->amLeben )
-	{
-		if( zKam->istSichtbar( (int)dat->xPos, (int)dat->yPos ) )
-		{
-			teamRahmen->setPosition( zKam->getRX( (int)dat->xPos ) - 5, zKam->getRY( (int)dat->yPos ) - 5 );
-			zRObj.fillRegion( teamRahmen->getX(), teamRahmen->getY(), 10, 10, spielerFarbe );
-			teamRahmen->render( zRObj );
-		}
-	}
+    VideoSpielerRundeDaten *dat = daten->get( runde );
+    if( dat->amLeben )
+    {
+        if( zKam->istSichtbar( (int)dat->xPos, (int)dat->yPos ) )
+        {
+            teamRahmen->setPosition( zKam->getRX( (int)dat->xPos ) - 5, zKam->getRY( (int)dat->yPos ) - 5 );
+            zRObj.fillRegion( teamRahmen->getX(), teamRahmen->getY(), 10, 10, spielerFarbe );
+            teamRahmen->render( zRObj );
+        }
+    }
 }
 
 // constant
 double VideoSpieler::getX() const
 {
-	return daten->get( runde )->xPos;
+    return daten->get( runde )->xPos;
 }
 
 double VideoSpieler::getY() const
 {
-	return daten->get( runde )->yPos;
+    return daten->get( runde )->yPos;
 }
 
 int VideoSpieler::getTeam() const
 {
-	return team;
+    return team;
 }
 
 int VideoSpieler::getTeamFarbe() const
 {
-	return teamFarbe;
+    return teamFarbe;
 }
 
 int VideoSpieler::getFarbe() const
 {
-	return spielerFarbe;
+    return spielerFarbe;
 }
 
 int VideoSpieler::getSpielerNummer() const
 {
-	return spielerNummer;
+    return spielerNummer;
 }
 
 bool VideoSpieler::istAmLeben() const
 {
-	return daten->get( runde )->amLeben;
+    return daten->get( runde )->amLeben;
 }
 
 Text *VideoSpieler::getName() const
 {
-	return name ? name->getThis() : 0;
+    return name ? dynamic_cast<Text *>( name->getThis() ) : 0;
 }
 
 Text *VideoSpieler::zName() const
 {
-	return name;
+    return name;
 }
 
 Text *VideoSpieler::getTeamName() const
 {
-	return teamName ? teamName->getThis() : 0;
+    return teamName ? dynamic_cast<Text *>( teamName->getThis() ) : 0;
 }
 
 Text *VideoSpieler::zTeamName() const
 {
-	return teamName;
+    return teamName;
 }
 
 bool VideoSpieler::istMausIn( int mx, int my ) const
 {
-	VideoSpielerRundeDaten *dat = daten->get( runde );
-	return mx >= (int)dat->xPos - 5 && mx <= (int)dat->xPos + 5 &&
-		   my >= (int)dat->yPos - 5 && my <= (int)dat->yPos + 5;
+    VideoSpielerRundeDaten *dat = daten->get( runde );
+    return mx >= (int)dat->xPos - 5 && mx <= (int)dat->xPos + 5 &&
+        my >= (int)dat->yPos - 5 && my <= (int)dat->yPos + 5;
 }
 
 int VideoSpieler::getGewonneneRunden() const
 {
-	return gewonneneRunden;
+    return gewonneneRunden;
 }
 
 int VideoSpieler::getLinienLänge() const
 {
-	return linienLänge;
+    return linienLänge;
 }
 
 int VideoSpieler::getZeitAmLeben() const
 {
-	return (int)zeitAmLeben;
+    return (int)zeitAmLeben;
 }
 
 int VideoSpieler::getZeitTod() const
 {
-	return (int)zeitTod;
+    return (int)zeitTod;
 }
 
 int VideoSpieler::getKills() const
 {
-	return kills;
+    return kills;
 }
 
 int VideoSpieler::getTode() const
 {
-	return tode;
+    return tode;
 }
 
 int VideoSpieler::getKillFarbe() const
 {
-	return killFarbe;
+    return killFarbe;
 }
 
 int VideoSpieler::getLinienLänge( int r ) const
 {
-	return rLinienLänge.get( r );
+    return rLinienLänge.get( r );
 }
 
 int VideoSpieler::getKills( int r ) const
 {
-	return rKills.get( r );
+    return rKills.get( r );
 }
 
 int VideoSpieler::getTodesZeit( int r ) const
 {
-	return rTodesZeit.get( r );
+    return rTodesZeit.get( r );
 }
 
 // Reference Counting
 VideoSpieler *VideoSpieler::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 VideoSpieler *VideoSpieler::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/HistorieStatistik/HistorieStatistik.cpp

@@ -11,200 +11,199 @@
 // Konstruktor
 HistorieStatistik::HistorieStatistik()
 {
-	schrift = 0;
-	screen = 0;
-	gss = new Array< SSDGesamtSpieler* >();
-	gts = new Array< SSDGesamtTeam* >();
-	rs = new Array< SSDRunde* >();
-	runde = 0;
-	tabelle = 0;
-	fertig = 0;
-	geladen = 0;
-	geschlossen = 0;
-	alpha = 0;
-	sichtbar = 0;
-	tickVal = 0;
-	rend = 0;
-	ref = 1;
+    schrift = 0;
+    screen = 0;
+    gss = new Array< SSDGesamtSpieler * >();
+    gts = new Array< SSDGesamtTeam * >();
+    rs = new Array< SSDRunde * >();
+    runde = 0;
+    tabelle = 0;
+    fertig = 0;
+    geladen = 0;
+    geschlossen = 0;
+    alpha = 0;
+    sichtbar = 0;
+    tickVal = 0;
+    rend = 0;
+    ref = 1;
 }
 
 // Destruktor
 HistorieStatistik::~HistorieStatistik()
 {
-	if( schrift )
-		schrift->release();
-	if( !geladen )
-	{
-		gss->release();
-		gts->release();
-		rs->release();
-	}
-	else
-	{
-		int anz = gss->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( gss->hat( i ) )
-				delete gss->get( i );
-		}
-		gss->release();
-		anz = gts->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( gts->hat( i ) )
-				delete gts->get( i );
-		}
-		gts->release();
-		anz = rs->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( rs->hat( i ) )
-			{
-				int anz2 = rs->get( i )->spieler.getEintragAnzahl();
-				for( int j = 0; j < anz2; j++ )
-				{
-					if( rs->get( i )->spieler.hat( j ) )
-						delete rs->get( i )->spieler.get( j );
-				}
-				anz2 = rs->get( i )->teams.getEintragAnzahl();
-				for( int j = 0; j < anz2; j++ )
-				{
-					if( rs->get( i )->teams.hat( j ) )
-						delete rs->get( i )->teams.get( j );
-				}
-				delete rs->get( i );
-			}
-		}
-		rs->release();
-	}
-	if( runde )
-		runde->release();
-	if( tabelle )
-		tabelle->release();
-	if( fertig )
-		fertig->release();
+    if( schrift )
+        schrift->release();
+    if( !geladen )
+    {
+        gss->release();
+        gts->release();
+        rs->release();
+    }
+    else
+    {
+        int anz = gss->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( gss->hat( i ) )
+                delete gss->get( i );
+        }
+        gss->release();
+        anz = gts->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( gts->hat( i ) )
+                delete gts->get( i );
+        }
+        gts->release();
+        anz = rs->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( rs->hat( i ) )
+            {
+                int anz2 = rs->get( i )->spieler.getEintragAnzahl();
+                for( int j = 0; j < anz2; j++ )
+                {
+                    if( rs->get( i )->spieler.hat( j ) )
+                        delete rs->get( i )->spieler.get( j );
+                }
+                anz2 = rs->get( i )->teams.getEintragAnzahl();
+                for( int j = 0; j < anz2; j++ )
+                {
+                    if( rs->get( i )->teams.hat( j ) )
+                        delete rs->get( i )->teams.get( j );
+                }
+                delete rs->get( i );
+            }
+        }
+        rs->release();
+    }
+    if( runde )
+        runde->release();
+    if( tabelle )
+        tabelle->release();
+    if( fertig )
+        fertig->release();
 }
 
 // nicht constant
 void HistorieStatistik::setSchrift( Schrift *schrift )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
 }
 
 void HistorieStatistik::setBildschirm( Bildschirm *zScreen )
 {
-	screen = zScreen;
+    screen = zScreen;
 }
 
 void HistorieStatistik::ladeDaten( int spielId )
 {
-	if( geladen )
-		return;
-	StatistikLeser *reader = new StatistikLeser( spielId );
-	for( int i = 0; i < reader->getSpielerAnzahl(); i++ )
-		gss->set( reader->getSSDGS( i ), i );
-	for( int i = 0; i < reader->getTeamAnzahl(); i++ )
-		gts->set( reader->getSSDGT( i ), i );
-	for( int i = 0; i < reader->getRundenAnzahl(); i++ )
-		rs->set( reader->getSSDR( i ), i );
-	reader->release();
-	tabelle = new StatistikTabelle( gss->getThis(), gts->getThis(), rs->getThis(), schrift, screen, 1 );
-	runde = new StatistikRunde( schrift, rs->getThis(), 1 );
-	fertig = initKnopf( 600, 390, 100, 20, schrift, Knopf::Style::Sichtbar, "Zurück" );
-	geladen = 1;
+    if( geladen )
+        return;
+    StatistikLeser *reader = new StatistikLeser( spielId );
+    for( int i = 0; i < reader->getSpielerAnzahl(); i++ )
+        gss->set( reader->getSSDGS( i ), i );
+    for( int i = 0; i < reader->getTeamAnzahl(); i++ )
+        gts->set( reader->getSSDGT( i ), i );
+    for( int i = 0; i < reader->getRundenAnzahl(); i++ )
+        rs->set( reader->getSSDR( i ), i );
+    reader->release();
+    tabelle = new StatistikTabelle( dynamic_cast<Array<SSDGesamtSpieler *> *>( gss->getThis() ), dynamic_cast<Array<SSDGesamtTeam *> *>( gts->getThis() ), dynamic_cast<Array<SSDRunde *> *>( rs->getThis() ), schrift, screen, 1 );
+    runde = new StatistikRunde( schrift, dynamic_cast<Array<SSDRunde *> *>( rs->getThis() ), 1 );
+    fertig = initKnopf( 600, 390, 100, 20, schrift, Knopf::Style::Sichtbar, "Zurück" );
+    geladen = 1;
 }
 
 void HistorieStatistik::setSichtbar( bool sichtbar )
 {
-	this->sichtbar = sichtbar;
+    this->sichtbar = sichtbar;
 }
 
 void HistorieStatistik::doPublicMausEreignis( MausEreignis &me )
 {
-	if( !geladen )
-		return;
-	tabelle->doPublicMausEreignis( me );
-	runde->doPublicMausEreignis( me );
-	bool vera = me.verarbeitet;
-	fertig->doPublicMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-		geschlossen = 1;
+    if( !geladen )
+        return;
+    tabelle->doPublicMausEreignis( me );
+    runde->doPublicMausEreignis( me );
+    bool vera = me.verarbeitet;
+    fertig->doPublicMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+        geschlossen = 1;
 }
 
 void HistorieStatistik::doTastaturEreignis( TastaturEreignis &te )
-{
-}
+{}
 
 bool HistorieStatistik::tick( double tickVal )
 {
-	if( !geladen )
-		return 0;
-	runde->setRunde( tabelle->getRunde() );
-	rend |= tabelle->tick( tickVal );
-	rend |= runde->tick( tickVal );
-	rend |= fertig->tick( tickVal );
-	this->tickVal += tickVal * 150;
-	int val = ( int )this->tickVal;
-	this->tickVal -= val;
-	if( val )
-	{
-		if( sichtbar && alpha != 255 )
-		{
-			if( alpha + val > 255 )
-				alpha = 255;
-			else
-				alpha += val;
-			rend = 1;
-		}
-		if( !sichtbar && alpha )
-		{
-			if( alpha - val < 0 )
-				alpha = 0;
-			else
-				alpha -= val;
-			rend = 1;
-		}
-	}
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    if( !geladen )
+        return 0;
+    runde->setRunde( tabelle->getRunde() );
+    rend |= tabelle->tick( tickVal );
+    rend |= runde->tick( tickVal );
+    rend |= fertig->tick( tickVal );
+    this->tickVal += tickVal * 150;
+    int val = (int)this->tickVal;
+    this->tickVal -= val;
+    if( val )
+    {
+        if( sichtbar && alpha != 255 )
+        {
+            if( alpha + val > 255 )
+                alpha = 255;
+            else
+                alpha += val;
+            rend = 1;
+        }
+        if( !sichtbar && alpha )
+        {
+            if( alpha - val < 0 )
+                alpha = 0;
+            else
+                alpha -= val;
+            rend = 1;
+        }
+    }
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void HistorieStatistik::render( Bild &zRObj )
 {
-	if( !geladen )
-		return;
-	zRObj.setAlpha( alpha );
-	tabelle->render( zRObj );
-	runde->render( zRObj );
-	fertig->render( zRObj );
-	zRObj.releaseAlpha();
+    if( !geladen )
+        return;
+    zRObj.setAlpha( alpha );
+    tabelle->render( zRObj );
+    runde->render( zRObj );
+    fertig->render( zRObj );
+    zRObj.releaseAlpha();
 }
 
 // constant
 bool HistorieStatistik::istNochSichtbar() const
 {
-	return alpha != 0 || sichtbar;
+    return alpha != 0 || sichtbar;
 }
 
 bool HistorieStatistik::wurdeGeschlossen() const
 {
-	return geschlossen;
+    return geschlossen;
 }
 
 // Reference Counting
 AccountHistorieStatistikV *HistorieStatistik::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 AccountHistorieStatistikV *HistorieStatistik::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Initialisierung/Initialisierung.cpp

@@ -5,211 +5,211 @@
 
 Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel )
 {
-	Knopf *ret = new Knopf();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( titel )
-	    ret->setText( titel );
-	return ret;
+    Knopf *ret = new Knopf();
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( zSchrift )
+        ret->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    if( titel )
+        ret->setText( titel );
+    return ret;
 }
 
 KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt )
 {
-	KontrollKnopf *ret = new KontrollKnopf();
-	ret->addStyle( style );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( txt )
-	{
-		ret->setText( txt );
-		ret->setSText( txt );
-	}
-	ret->setSFarbe( 0xFFFFFFFF );
-	ret->setSSize( 12 );
-	if( ret->hatStyle( TextFeld::Style::Buffered ) )
-	{
-		ret->setAlphaFeldFarbe( 0x5500FF00 );
-		ret->setAlphaFeldStrength( -5 );
-	}
-	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFF00FF00 );
-	}
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	ret->loadData( "data/bilder/system.ltdb" );
-	return ret;
+    KontrollKnopf *ret = new KontrollKnopf();
+    ret->addStyle( style );
+    if( zSchrift )
+        ret->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    if( txt )
+    {
+        ret->setText( txt );
+        ret->setSText( txt );
+    }
+    ret->setSFarbe( 0xFFFFFFFF );
+    ret->setSSize( 12 );
+    if( ret->hatStyle( TextFeld::Style::Buffered ) )
+    {
+        ret->setAlphaFeldFarbe( 0x5500FF00 );
+        ret->setAlphaFeldStrength( -5 );
+    }
+    if( ret->hatStyle( TextFeld::Style::Rahmen ) )
+    {
+        ret->setRahmenBreite( 1 );
+        ret->setRahmenFarbe( 0xFF00FF00 );
+    }
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    ret->loadData( "data/bilder/system.ltdb" );
+    return ret;
 }
 
 Fenster *initFenster( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel )
 {
-	Fenster *ret = new Fenster();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ret->hatStyle( Fenster::Style::Rahmen ) )
-	{
-		ret->setRBreite( 1 );
-		ret->setRFarbe( 0xFFFFFFFF );
-	}
-	if( ret->hatStyle( Fenster::Style::Titel ) )
-	{
-		if( titel )
-		    ret->setTitel( titel );
-		if( zSchrift )
-		    ret->setTSchriftZ( zSchrift->getThis() );
-		ret->setTSFarbe( 0xFFFFFFFF );
-		ret->zTTextFeld()->setSize( 0, 20 );
-		ret->zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
-		ret->setTRFarbe( 0xFF00FF00 );
-		ret->setTRBreite( 1 );
-		if( ret->hatStyle( Fenster::Style::TitelBuffered ) )
-		{
-			ret->setTAfFarbe( 0x1000FF00 );
-			ret->setTAfStrength( -15 );
-		}
-	}
-	return ret;
+    Fenster *ret = new Fenster();
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( ret->hatStyle( Fenster::Style::Rahmen ) )
+    {
+        ret->setRBreite( 1 );
+        ret->setRFarbe( 0xFFFFFFFF );
+    }
+    if( ret->hatStyle( Fenster::Style::Titel ) )
+    {
+        if( titel )
+            ret->setTitel( titel );
+        if( zSchrift )
+            ret->setTSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+        ret->setTSFarbe( 0xFFFFFFFF );
+        ret->zTTextFeld()->setSize( 0, 20 );
+        ret->zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
+        ret->setTRFarbe( 0xFF00FF00 );
+        ret->setTRBreite( 1 );
+        if( ret->hatStyle( Fenster::Style::TitelBuffered ) )
+        {
+            ret->setTAfFarbe( 0x1000FF00 );
+            ret->setTAfStrength( -15 );
+        }
+    }
+    return ret;
 }
 
 TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt )
 {
-	TextFeld *ret = new TextFeld();
-	ret->setStyle( style );
-	if( zSchrift )
-	    ret->setSchriftZ( zSchrift->getThis() );
-	if( txt )
-	   ret->setText( txt );
-	ret->setSchriftFarbe( 0xFFFFFFFF );
-	ret->setSchriftSize( 12 );
-	if( ret->hatStyle( TextFeld::Style::Buffered ) )
-	{
-		ret->setAlphaFeldFarbe( 0x5500FF00 );
-		ret->setAlphaFeldStrength( -5 );
-	}
-	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFF00FF00 );
-	}
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	return ret;
+    TextFeld *ret = new TextFeld();
+    ret->setStyle( style );
+    if( zSchrift )
+        ret->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    if( txt )
+        ret->setText( txt );
+    ret->setSchriftFarbe( 0xFFFFFFFF );
+    ret->setSchriftSize( 12 );
+    if( ret->hatStyle( TextFeld::Style::Buffered ) )
+    {
+        ret->setAlphaFeldFarbe( 0x5500FF00 );
+        ret->setAlphaFeldStrength( -5 );
+    }
+    if( ret->hatStyle( TextFeld::Style::Rahmen ) )
+    {
+        ret->setRahmenBreite( 1 );
+        ret->setRahmenFarbe( 0xFF00FF00 );
+    }
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    return ret;
 }
 
 BildZ *initBildZ( int x, int y, int br, int hö, int style, Bild *b )
 {
-	BildZ *ret = new BildZ();
-	ret->setStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( b )
-		ret->setBildZ( b );
-	if( ( style | BildZ::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	return ret;
+    BildZ *ret = new BildZ();
+    ret->setStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( b )
+        ret->setBildZ( b );
+    if( ( style | BildZ::Style::Rahmen ) == style )
+    {
+        ret->setRahmenBreite( 1 );
+        ret->setRahmenFarbe( 0xFFFFFFFF );
+    }
+    return ret;
 }
 
 AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< char * > values )
 {
-	AuswahlBox *ret = new AuswahlBox();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ( style | AuswahlBox::Style::Hintergrund ) == style )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	if( ( style | AuswahlBox::Style::Erlaubt ) == style )
-		ret->setMausEreignis( _ret1ME );
-	if( zSchrift )
-	    ret->setSchriftZ( zSchrift->getThis() );
-	if( ( style | AuswahlBox::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | AuswahlBox::Style::MaxHeight ) == style )
-		ret->setMaxAuskappHeight( 100 );
-	if( ( style | AuswahlBox::Style::MausRahmen ) == style )
-	{
-		ret->setMausRahmenBreite( 1 );
-		ret->setMausRahmenFarbe( 0xFF005500 );
-	}
-	if( ( style | AuswahlBox::Style::MausBuffer ) == style )
-	{
-		ret->setMausAlphaFeldFarbe( 0x00008700 );
-		ret->setMausAlphaFeldStrength( -8 );
-	}
-	if( ( style | AuswahlBox::Style::AuswahlRahmen ) == style )
-	{
-		ret->setAuswRahmenBreite( 1 );
-		ret->setAuswRahmenFarbe( 0xFF00FF00 );
-	}
-	if( ( style | AuswahlBox::Style::AuswahlBuffer ) == style )
-	{
-		ret->setAuswAlphaFeldFarbe( 0x0000FF00 );
-		ret->setAuswAlphaFeldStrength( -8 );
-	}
-	for( auto i = values.begin(); i != values.end(); i++ )
-	{
-		ret->addEintrag( *i );
-	}
-	return ret;
+    AuswahlBox *ret = new AuswahlBox();
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( ( style | AuswahlBox::Style::Hintergrund ) == style )
+        ret->setHintergrundFarbe( 0xFF000000 );
+    if( ( style | AuswahlBox::Style::Erlaubt ) == style )
+        ret->setMausEreignis( _ret1ME );
+    if( zSchrift )
+        ret->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    if( ( style | AuswahlBox::Style::Rahmen ) == style )
+    {
+        ret->setRahmenBreite( 1 );
+        ret->setRahmenFarbe( 0xFFFFFFFF );
+    }
+    if( ( style | AuswahlBox::Style::MaxHeight ) == style )
+        ret->setMaxAuskappHeight( 100 );
+    if( ( style | AuswahlBox::Style::MausRahmen ) == style )
+    {
+        ret->setMausRahmenBreite( 1 );
+        ret->setMausRahmenFarbe( 0xFF005500 );
+    }
+    if( ( style | AuswahlBox::Style::MausBuffer ) == style )
+    {
+        ret->setMausAlphaFeldFarbe( 0x00008700 );
+        ret->setMausAlphaFeldStrength( -8 );
+    }
+    if( ( style | AuswahlBox::Style::AuswahlRahmen ) == style )
+    {
+        ret->setAuswRahmenBreite( 1 );
+        ret->setAuswRahmenFarbe( 0xFF00FF00 );
+    }
+    if( ( style | AuswahlBox::Style::AuswahlBuffer ) == style )
+    {
+        ret->setAuswAlphaFeldFarbe( 0x0000FF00 );
+        ret->setAuswAlphaFeldStrength( -8 );
+    }
+    for( auto i = values.begin(); i != values.end(); i++ )
+    {
+        ret->addEintrag( *i );
+    }
+    return ret;
 }
 
 ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
 {
-	ObjTabelle *ret = new ObjTabelle();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ( style | ObjTabelle::Style::Erlaubt ) == style )
-		ret->setMausEreignis( _ret1ME );
-	if( ( style | ObjTabelle::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | ObjTabelle::Style::Raster ) == style )
-	{
-		ret->setRasterBreite( 1 );
-		ret->setRasterFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | ObjTabelle::Style::VScroll ) == style )
-		ret->setVertikalKlickScroll( 5 );
-	if( ( style | ObjTabelle::Style::HScroll ) == style )
-		ret->setHorizontalKlickScroll( 5 );
-	for( auto i = spalten.begin(); i != spalten.end(); i++ )
-	{
-		ret->addSpalte( i->name );
-		ret->setSpaltenBreite( i->name, i->breite );
-		if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
-			ret->setMinSpaltenBreite( i->name, i->minBreite );
-		if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
-			ret->setMaxSpaltenBreite( i->name, i->maxBreite );
-		if( überschriftHöhe )
-		{
-			if( ret->getZeilenNummer( "Überschrift" ) < 0 )
-			{
-				ret->addZeile( 0, "Überschrift" );
-				ret->setZeilenHeight( 0, 20 );
-			}
-			ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, zSchrift, TextFeld::Style::Text, i->name ) );
-		}
-	}
-	return ret;
+    ObjTabelle *ret = new ObjTabelle();
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( ( style | ObjTabelle::Style::Erlaubt ) == style )
+        ret->setMausEreignis( _ret1ME );
+    if( ( style | ObjTabelle::Style::Rahmen ) == style )
+    {
+        ret->setRahmenBreite( 1 );
+        ret->setRahmenFarbe( 0xFFFFFFFF );
+    }
+    if( ( style | ObjTabelle::Style::Raster ) == style )
+    {
+        ret->setRasterBreite( 1 );
+        ret->setRasterFarbe( 0xFFFFFFFF );
+    }
+    if( ( style | ObjTabelle::Style::VScroll ) == style )
+        ret->setVertikalKlickScroll( 5 );
+    if( ( style | ObjTabelle::Style::HScroll ) == style )
+        ret->setHorizontalKlickScroll( 5 );
+    for( auto i = spalten.begin(); i != spalten.end(); i++ )
+    {
+        ret->addSpalte( i->name );
+        ret->setSpaltenBreite( i->name, i->breite );
+        if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
+            ret->setMinSpaltenBreite( i->name, i->minBreite );
+        if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
+            ret->setMaxSpaltenBreite( i->name, i->maxBreite );
+        if( überschriftHöhe )
+        {
+            if( ret->getZeilenNummer( "Überschrift" ) < 0 )
+            {
+                ret->addZeile( 0, "Überschrift" );
+                ret->setZeilenHeight( 0, 20 );
+            }
+            ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, zSchrift, TextFeld::Style::Text, i->name ) );
+        }
+    }
+    return ret;
 }
 
 void initToolTip( Zeichnung *obj, const char *txt, Schrift *zSchrift, Bildschirm *zBs )
 {
-	obj->setToolTipText( txt, zBs, zSchrift );
-	obj->zToolTip()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha | TextFeld::Style::Mehrzeilig );
-	obj->zToolTip()->setHintergrundFarbe( 0xA0000000 );
-	obj->zToolTip()->setRahmenFarbe( 0xFFFFFFFF );
+    obj->setToolTipText( txt, zBs, zSchrift );
+    obj->zToolTip()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha | TextFeld::Style::Mehrzeilig );
+    obj->zToolTip()->setHintergrundFarbe( 0xA0000000 );
+    obj->zToolTip()->setRahmenFarbe( 0xFFFFFFFF );
 }

Linie/Spiel/Bestenliste/Bestenliste.cpp

@@ -9,646 +9,646 @@
 // Konstruktor
 BLSpieler::BLSpieler( int sNum, int farbe, Schrift *zS )
 {
-	this->sNum = sNum;
-	this->farbe = farbe;
-	p = 0;
-	nP = 0;
-
-	rahmen = new LRahmen();
-	rahmen->setFarbe( farbe );
-	rahmen->setRamenBreite( 1 );
-	rahmen->setSize( 400, 20 );
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	name->setSchriftZ( zS->getThis() );
-	name->setSchriftFarbe( farbe );
-	name->setSchriftSize( 12 );
-	name->setSize( 100, 20 );
-	name->setPosition( 0, 0 );
-	name->setText( "" );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	punkte->setSchriftZ( zS->getThis() );
-	punkte->setSchriftFarbe( farbe );
-	punkte->setSchriftSize( 12 );
-	punkte->setSize( 100, 20 );
-	punkte->setPosition( 100, 0 );
-	punkte->setText( "" );
-
-	neuPunkte = new TextFeld();
-	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	neuPunkte->setSchriftZ( zS->getThis() );
-	neuPunkte->setSchriftFarbe( farbe );
-	neuPunkte->setSchriftSize( 12 );
-	neuPunkte->setSize( 100, 20 );
-	neuPunkte->setPosition( 200, 0 );
-	neuPunkte->setText( "" );
-
-	status = new TextFeld();
-	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	status->setSchriftZ( zS->getThis() );
-	status->setSchriftFarbe( 0xFF00FF00 );
-	status->setSchriftSize( 12 );
-	status->setSize( 100, 20 );
-	status->setPosition( 300, 0 );
-	status->setText( "lebt" );
-
-	ref = 1;
+    this->sNum = sNum;
+    this->farbe = farbe;
+    p = 0;
+    nP = 0;
+
+    rahmen = new LRahmen();
+    rahmen->setFarbe( farbe );
+    rahmen->setRamenBreite( 1 );
+    rahmen->setSize( 400, 20 );
+
+    name = new TextFeld();
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    name->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    name->setSchriftFarbe( farbe );
+    name->setSchriftSize( 12 );
+    name->setSize( 100, 20 );
+    name->setPosition( 0, 0 );
+    name->setText( "" );
+
+    punkte = new TextFeld();
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    punkte->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    punkte->setSchriftFarbe( farbe );
+    punkte->setSchriftSize( 12 );
+    punkte->setSize( 100, 20 );
+    punkte->setPosition( 100, 0 );
+    punkte->setText( "" );
+
+    neuPunkte = new TextFeld();
+    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    neuPunkte->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    neuPunkte->setSchriftFarbe( farbe );
+    neuPunkte->setSchriftSize( 12 );
+    neuPunkte->setSize( 100, 20 );
+    neuPunkte->setPosition( 200, 0 );
+    neuPunkte->setText( "" );
+
+    status = new TextFeld();
+    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    status->setSchriftZ( dynamic_cast<Schrift *>( zS->getThis() ) );
+    status->setSchriftFarbe( 0xFF00FF00 );
+    status->setSchriftSize( 12 );
+    status->setSize( 100, 20 );
+    status->setPosition( 300, 0 );
+    status->setText( "lebt" );
+
+    ref = 1;
 }
 
 // Destruktor
 BLSpieler::~BLSpieler()
 {
-	rahmen->release();
-	name->release();
-	punkte->release();
-	neuPunkte->release();
-	status->release();
+    rahmen->release();
+    name->release();
+    punkte->release();
+    neuPunkte->release();
+    status->release();
 }
 
 // nicht constant
 bool BLSpieler::updateStatus( Spieler *zSpieler )
 {
-	if( sNum != zSpieler->getSpielerNummer() )
-		return 0;
-	if( zSpieler->istAmLeben() )
-	{
-		status->setSchriftFarbe( 0xFF00FF00 );
-		status->setText( "lebt" );
-	}
-	else
-	{
-		status->setSchriftFarbe( 0xFFFF0000 );
-		status->setText( "tot" );
-	}
-	name->setText( zSpieler->zName()->getText() );
-	return 1;
+    if( sNum != zSpieler->getSpielerNummer() )
+        return 0;
+    if( zSpieler->istAmLeben() )
+    {
+        status->setSchriftFarbe( 0xFF00FF00 );
+        status->setText( "lebt" );
+    }
+    else
+    {
+        status->setSchriftFarbe( 0xFFFF0000 );
+        status->setText( "tot" );
+    }
+    name->setText( zSpieler->zName()->getText() );
+    return 1;
 }
 
 void BLSpieler::setPunkte( int p )
 {
-	this->p = p;
+    this->p = p;
 }
 
 void BLSpieler::addPunkt( bool plus )
 {
-	if( plus )
-		nP++;
-	else
-		nP--;
+    if( plus )
+        nP++;
+    else
+        nP--;
 }
 
 void BLSpieler::updatePunkte()
 {
-	p += nP;
-	nP = 0;
+    p += nP;
+    nP = 0;
 }
 
 void BLSpieler::render( int y, Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	punkte->setText( "" );
-	if( nP == 0 )
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
-	}
-	else if( nP > 0 )
-	{
-		neuPunkte->setText( "+" );
-		neuPunkte->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFF0000 );
-	}
-	punkte->zText()->append( p );
-	neuPunkte->zText()->append( nP );
-	rahmen->render( zRObj );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	neuPunkte->render( zRObj );
-	status->render( zRObj );
-	zRObj.releaseDrawOptions();
+    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    punkte->setText( "" );
+    if( nP == 0 )
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
+    }
+    else if( nP > 0 )
+    {
+        neuPunkte->setText( "+" );
+        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
+    }
+    punkte->zText()->append( p );
+    neuPunkte->zText()->append( nP );
+    rahmen->render( zRObj );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    neuPunkte->render( zRObj );
+    status->render( zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int BLSpieler::getSpielerNummer() const
 {
-	return sNum;
+    return sNum;
 }
 
 int BLSpieler::getPunkte() const
 {
-	return p + nP;
+    return p + nP;
 }
 
 // Reference Counting
 BLSpieler *BLSpieler::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 BLSpieler *BLSpieler::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der BLTeam Klasse aus Bestenliste.h
 // Konstruktor
 BLTeam::BLTeam( int id, int farbe, Schrift *s )
 {
-	teamId = id;
-	spielerAnzahl = 0;
-	p = 0;
-	mP = 0;
-	nP = 0;
-	this->farbe = farbe;
-	schrift = s;
-
-	rahmen = new LRahmen();
-	rahmen->setFarbe( farbe );
-	rahmen->setRamenBreite( 1 );
-
-	spieler = new RCArray< BLSpieler >();
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	name->setSchriftZ( s->getThis() );
-	name->setSchriftFarbe( farbe );
-	name->setSchriftSize( 12 );
-	name->setSize( 100, 20 );
-	name->setPosition( 0, 0 );
-	name->setText( "" );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	punkte->setSchriftZ( s->getThis() );
-	punkte->setSchriftFarbe( farbe );
-	punkte->setSchriftSize( 12 );
-	punkte->setSize( 100, 20 );
-	punkte->setPosition( 100, 0 );
-	punkte->setText( "" );
-
-	neuPunkte = new TextFeld();
-	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	neuPunkte->setSchriftZ( s->getThis() );
-	neuPunkte->setSchriftFarbe( farbe );
-	neuPunkte->setSchriftSize( 12 );
-	neuPunkte->setSize( 100, 20 );
-	neuPunkte->setPosition( 200, 0 );
-	neuPunkte->setText( "" );
-
-	status = new TextFeld();
-	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	status->setSchriftZ( s->getThis() );
-	status->setSchriftFarbe( 0xFF00FF00 );
-	status->setSchriftSize( 12 );
-	status->setSize( 100, 20 );
-	status->setPosition( 300, 0 );
-	status->setText( "lebt" );
-
-	ref = 1;
+    teamId = id;
+    spielerAnzahl = 0;
+    p = 0;
+    mP = 0;
+    nP = 0;
+    this->farbe = farbe;
+    schrift = s;
+
+    rahmen = new LRahmen();
+    rahmen->setFarbe( farbe );
+    rahmen->setRamenBreite( 1 );
+
+    spieler = new RCArray< BLSpieler >();
+
+    name = new TextFeld();
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    name->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    name->setSchriftFarbe( farbe );
+    name->setSchriftSize( 12 );
+    name->setSize( 100, 20 );
+    name->setPosition( 0, 0 );
+    name->setText( "" );
+
+    punkte = new TextFeld();
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    punkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    punkte->setSchriftFarbe( farbe );
+    punkte->setSchriftSize( 12 );
+    punkte->setSize( 100, 20 );
+    punkte->setPosition( 100, 0 );
+    punkte->setText( "" );
+
+    neuPunkte = new TextFeld();
+    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    neuPunkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    neuPunkte->setSchriftFarbe( farbe );
+    neuPunkte->setSchriftSize( 12 );
+    neuPunkte->setSize( 100, 20 );
+    neuPunkte->setPosition( 200, 0 );
+    neuPunkte->setText( "" );
+
+    status = new TextFeld();
+    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    status->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    status->setSchriftFarbe( 0xFF00FF00 );
+    status->setSchriftSize( 12 );
+    status->setSize( 100, 20 );
+    status->setPosition( 300, 0 );
+    status->setText( "lebt" );
+
+    ref = 1;
 }
 
 // Destruktor
 BLTeam::~BLTeam()
 {
-	schrift->release();
-	rahmen->release();
-	spieler->release();
-	name->release();
-	punkte->release();
-	neuPunkte->release();
-	status->release();
+    schrift->release();
+    rahmen->release();
+    spieler->release();
+    name->release();
+    punkte->release();
+    neuPunkte->release();
+    status->release();
 }
 
 // nicht constant
 bool BLTeam::addSpieler( Spieler *zSpieler )
 {
-	bool gefunden = 0;
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-		{
-			gefunden = 1;
-			break;
-		}
-	}
-	if( gefunden )
-		return 0;
-	BLSpieler *tmp = new BLSpieler( zSpieler->getSpielerNummer(), zSpieler->getFarbe(), schrift );
-	spieler->set( tmp, spielerAnzahl );
-	spielerAnzahl++;
-	return 1;
+    bool gefunden = 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+        {
+            gefunden = 1;
+            break;
+        }
+    }
+    if( gefunden )
+        return 0;
+    BLSpieler *tmp = new BLSpieler( zSpieler->getSpielerNummer(), zSpieler->getFarbe(), schrift );
+    spieler->set( tmp, spielerAnzahl );
+    spielerAnzahl++;
+    return 1;
 }
 
 void BLTeam::setName( char *name )
 {
-	this->name->setText( name );
+    this->name->setText( name );
 }
 
 bool BLTeam::updateSpielerStatus( Spieler *zSpieler )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-		{
-			spieler->z( i )->updateStatus( zSpieler );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+        {
+            spieler->z( i )->updateStatus( zSpieler );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void BLTeam::setStatus( const char *txt, int f )
 {
-	status->setText( txt );
-	status->setSchriftFarbe( f );
+    status->setText( txt );
+    status->setSchriftFarbe( f );
 }
 
 void BLTeam::setPunkte( int p )
 {
-	this->p = p;
+    this->p = p;
 }
 
 void BLTeam::setMaxPunkte( int mP )
 {
-	this->mP = mP;
+    this->mP = mP;
 }
 
 bool BLTeam::setSpielerPunkte( int sNum, int p )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == sNum )
-		{
-			spieler->z( i )->setPunkte( p );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == sNum )
+        {
+            spieler->z( i )->setPunkte( p );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void BLTeam::addPunkt( bool plus )
 {
-	if( plus )
-		nP++;
-	else
-		nP--;
-	if( p + nP < 0 )
-		nP++;
+    if( plus )
+        nP++;
+    else
+        nP--;
+    if( p + nP < 0 )
+        nP++;
 }
 
 bool BLTeam::addPunkt( int sNum, bool plus )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == sNum )
-		{
-			spieler->z( i )->addPunkt( plus );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == sNum )
+        {
+            spieler->z( i )->addPunkt( plus );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void BLTeam::updatePunkte()
 {
-	p += nP;
-	if( p < 0 )
-		p = 0;
-	nP = 0;
-	for( int i = 0; i < spielerAnzahl; i++ )
-		spieler->z( i )->updatePunkte();
+    p += nP;
+    if( p < 0 )
+        p = 0;
+    nP = 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+        spieler->z( i )->updatePunkte();
 }
 
 void BLTeam::render( int y, Bild &zRObj )
 {
-	rahmen->setSize( 402, 21 + 20 * spielerAnzahl );
-	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	punkte->setText( "" );
-	if( nP == 0 )
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
-	}
-	else if( nP > 0 )
-	{
-		neuPunkte->setText( "+" );
-		neuPunkte->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else
-	{
-		neuPunkte->setText( "" );
-		neuPunkte->setSchriftFarbe( 0xFFFF0000 );
-	}
-	punkte->zText()->append( p );
-	punkte->zText()->append( "/" );
-	punkte->zText()->append( mP );
-	neuPunkte->zText()->append( nP );
-	rahmen->render( zRObj );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	neuPunkte->render( zRObj );
-	status->render( zRObj );
-	Array< bool > *gemahlt = new Array< bool >();
-	for( int i = 0; i < spielerAnzahl; i++ )
-		gemahlt->set( 0, i );
-	int min = -1;
-	int tmp = -1;
-	for( int h = 0; h < spielerAnzahl; h++ )
-	{
-		min = -1;
-		tmp = -1;
-		for( int i = 0; i < spielerAnzahl; i++ )
-		{
-			if( !spieler->z( i ) )
-				continue;
-			if( gemahlt->hat( i ) && gemahlt->get( i ) )
-				continue;
-			int p = spieler->z( i )->getPunkte();
-			if( p > min )
-			{
-				min = p;
-				tmp = i;
-			}
-		}
-		if( tmp >= 0 )
-		{
-			gemahlt->set( 1, tmp );
-			spieler->z( tmp )->render( 20 + 20 * h, zRObj );
-		}
-		else
-			break;
-	}
-	gemahlt->release();
-	zRObj.releaseDrawOptions();
+    rahmen->setSize( 402, 21 + 20 * spielerAnzahl );
+    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    punkte->setText( "" );
+    if( nP == 0 )
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
+    }
+    else if( nP > 0 )
+    {
+        neuPunkte->setText( "+" );
+        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else
+    {
+        neuPunkte->setText( "" );
+        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
+    }
+    punkte->zText()->append( p );
+    punkte->zText()->append( "/" );
+    punkte->zText()->append( mP );
+    neuPunkte->zText()->append( nP );
+    rahmen->render( zRObj );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    neuPunkte->render( zRObj );
+    status->render( zRObj );
+    Array< bool > *gemahlt = new Array< bool >();
+    for( int i = 0; i < spielerAnzahl; i++ )
+        gemahlt->set( 0, i );
+    int min = -1;
+    int tmp = -1;
+    for( int h = 0; h < spielerAnzahl; h++ )
+    {
+        min = -1;
+        tmp = -1;
+        for( int i = 0; i < spielerAnzahl; i++ )
+        {
+            if( !spieler->z( i ) )
+                continue;
+            if( gemahlt->hat( i ) && gemahlt->get( i ) )
+                continue;
+            int p = spieler->z( i )->getPunkte();
+            if( p > min )
+            {
+                min = p;
+                tmp = i;
+            }
+        }
+        if( tmp >= 0 )
+        {
+            gemahlt->set( 1, tmp );
+            spieler->z( tmp )->render( 20 + 20 * h, zRObj );
+        }
+        else
+            break;
+    }
+    gemahlt->release();
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int BLTeam::getSpielerAnzahl() const
 {
-	return spielerAnzahl;
+    return spielerAnzahl;
 }
 
 int BLTeam::getPunkte() const
 {
-	return ( p + nP ) < 0 ? 0 : ( p + nP );
+    return ( p + nP ) < 0 ? 0 : ( p + nP );
 }
 
 int BLTeam::getHeight() const
 {
-	return 21 + spielerAnzahl * 20;
+    return 21 + spielerAnzahl * 20;
 }
 
 // Reference Counting
 BLTeam *BLTeam::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 BLTeam *BLTeam::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der Bestenliste Klasse aus Bestenliste.h
 // Konstruktor
 Bestenliste::Bestenliste( Schrift *s )
 {
-	rahmen = new LRahmen();
-	rahmen->setRamenBreite( 1 );
-	rahmen->setFarbe( 0xFFFFFFFF );
-	rahmen->setSize( 420, 200 );
-
-	teams = new RCArray< BLTeam >();
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	name->setSchriftZ( s->getThis() );
-	name->setSchriftFarbe( 0xFFFFFFFF );
-	name->setSchriftSize( 12 );
-	name->setText( "Name" );
-	name->setSize( 100, 20 );
-	name->setPosition( 0, 0 );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	punkte->setSchriftZ( s->getThis() );
-	punkte->setSchriftFarbe( 0xFFFFFFFF );
-	punkte->setSchriftSize( 12 );
-	punkte->setText( "Punkte" );
-	punkte->setSize( 100, 20 );
-	punkte->setPosition( 100, 0 );
-
-	neuPunkte = new TextFeld();
-	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	neuPunkte->setSchriftZ( s->getThis() );
-	neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
-	neuPunkte->setSchriftSize( 12 );
-	neuPunkte->setText( "+Punkte" );
-	neuPunkte->setSize( 100, 20 );
-	neuPunkte->setPosition( 200, 0 );
-
-	status = new TextFeld();
-	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	status->setSchriftZ( s->getThis() );
-	status->setSchriftFarbe( 0xFFFFFFFF );
-	status->setSchriftSize( 12 );
-	status->setText( "Status" );
-	status->setSize( 100, 20 );
-	status->setPosition( 300, 0 );
-
-	scroll = new VScrollBar();
-	scroll->setKlickScroll( 7 );
-
-	schrift = s;
-	update = 0;
-	teamAnzahl = 0;
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setRamenBreite( 1 );
+    rahmen->setFarbe( 0xFFFFFFFF );
+    rahmen->setSize( 420, 200 );
+
+    teams = new RCArray< BLTeam >();
+
+    name = new TextFeld();
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    name->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    name->setSchriftFarbe( 0xFFFFFFFF );
+    name->setSchriftSize( 12 );
+    name->setText( "Name" );
+    name->setSize( 100, 20 );
+    name->setPosition( 0, 0 );
+
+    punkte = new TextFeld();
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    punkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    punkte->setSchriftFarbe( 0xFFFFFFFF );
+    punkte->setSchriftSize( 12 );
+    punkte->setText( "Punkte" );
+    punkte->setSize( 100, 20 );
+    punkte->setPosition( 100, 0 );
+
+    neuPunkte = new TextFeld();
+    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    neuPunkte->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
+    neuPunkte->setSchriftSize( 12 );
+    neuPunkte->setText( "+Punkte" );
+    neuPunkte->setSize( 100, 20 );
+    neuPunkte->setPosition( 200, 0 );
+
+    status = new TextFeld();
+    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    status->setSchriftZ( dynamic_cast<Schrift *>( s->getThis() ) );
+    status->setSchriftFarbe( 0xFFFFFFFF );
+    status->setSchriftSize( 12 );
+    status->setText( "Status" );
+    status->setSize( 100, 20 );
+    status->setPosition( 300, 0 );
+
+    scroll = new VScrollBar();
+    scroll->setKlickScroll( 7 );
+
+    schrift = s;
+    update = 0;
+    teamAnzahl = 0;
+    ref = 1;
 }
 
 // Destruktor
 Bestenliste::~Bestenliste()
 {
-	rahmen->release();
-	teams->release();
-	name->release();
-	punkte->release();
-	neuPunkte->release();
-	status->release();
-	scroll->release();
-	schrift->release();
+    rahmen->release();
+    teams->release();
+    name->release();
+    punkte->release();
+    neuPunkte->release();
+    status->release();
+    scroll->release();
+    schrift->release();
 }
 
 // nicht constant
 void Bestenliste::setTeamAnzahl( int anz )
 {
-	teamAnzahl = anz;
+    teamAnzahl = anz;
 }
 
 void Bestenliste::setTeamStatus( int team, const char *txt, int f )
 {
-	if( teams->z( team ) )
-		teams->z( team )->setStatus( txt, f );
+    if( teams->z( team ) )
+        teams->z( team )->setStatus( txt, f );
 }
 
 void Bestenliste::addSpieler( Spieler *zSpieler )
 {
-	int team = zSpieler->getTeam();
-	if( team < 0 )
-		return;
-	if( !teams->z( team ) )
-		teams->set( new BLTeam( team, zSpieler->getTeamFarbe(), schrift->getThis() ), team );
-	teams->z( team )->addSpieler( zSpieler );
+    int team = zSpieler->getTeam();
+    if( team < 0 )
+        return;
+    if( !teams->z( team ) )
+        teams->set( new BLTeam( team, zSpieler->getTeamFarbe(), dynamic_cast<Schrift *>( schrift->getThis() ) ), team );
+    teams->z( team )->addSpieler( zSpieler );
 }
 
 void Bestenliste::updateSpielerStatus( Spieler *zSpieler )
 {
-	if( teams->z( zSpieler->getTeam() ) )
-		teams->z( zSpieler->getTeam() )->updateSpielerStatus( zSpieler );
+    if( teams->z( zSpieler->getTeam() ) )
+        teams->z( zSpieler->getTeam() )->updateSpielerStatus( zSpieler );
 }
 
 void Bestenliste::setTeamName( int team, char *name )
 {
-	if( teams->z( team ) )
-		teams->z( team )->setName( name );
+    if( teams->z( team ) )
+        teams->z( team )->setName( name );
 }
 
 void Bestenliste::setTeamPunkte( int teamId, int punkte )
 {
-	if( teams->z( teamId ) )
-		teams->z( teamId )->setPunkte( punkte );
+    if( teams->z( teamId ) )
+        teams->z( teamId )->setPunkte( punkte );
 }
 
 void Bestenliste::setTeamMaxPunkte( int teamId, int mPunkte )
 {
-	if( teams->z( teamId ) )
-		teams->z( teamId )->setMaxPunkte( mPunkte );
+    if( teams->z( teamId ) )
+        teams->z( teamId )->setMaxPunkte( mPunkte );
 }
 
 void Bestenliste::setSpielerPunkte( int teamNum, int sNum, int punkte )
 {
-	if( teams->z( teamNum ) )
-		teams->z( teamNum )->setSpielerPunkte( sNum, punkte );
+    if( teams->z( teamNum ) )
+        teams->z( teamNum )->setSpielerPunkte( sNum, punkte );
 }
 
 void Bestenliste::addPunkt( int tNum, bool plus )
 {
-	if( teams->z( tNum ) )
-		teams->z( tNum )->addPunkt( plus );
+    if( teams->z( tNum ) )
+        teams->z( tNum )->addPunkt( plus );
 }
 
 void Bestenliste::addPunkt( int tNum, int sNum, bool plus )
 {
-	if( teams->z( tNum ) )
-		teams->z( tNum )->addPunkt( sNum, plus );
+    if( teams->z( tNum ) )
+        teams->z( tNum )->addPunkt( sNum, plus );
 }
 
 void Bestenliste::updatePunkte()
 {
-	for( int i = 0; i < teamAnzahl; i++ )
-	{
-		if( teams->z( i ) )
-			teams->z( i )->updatePunkte();
-	}
+    for( int i = 0; i < teamAnzahl; i++ )
+    {
+        if( teams->z( i ) )
+            teams->z( i )->updatePunkte();
+    }
 }
 
 void Bestenliste::doPublicMausEreignis( MausEreignis &me )
 {
-	scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
+    scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
 }
 
 void Bestenliste::render( Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	rahmen->render( zRObj );
-	zRObj.addScrollOffset( 0, scroll->getScroll() );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	neuPunkte->render( zRObj );
-	status->render( zRObj );
-	int yOff = 20;
-	Array< bool > *gemahlt = new Array< bool >();
-	for( int i = 0; i < teamAnzahl; i++ )
-		gemahlt->set( 0, i );
-	int min = -1;
-	int tmp = -1;
-	for( int h = 0; h < teamAnzahl; h++ )
-	{
-		min = -1;
-		tmp = -1;
-		for( int i = 0; i < teamAnzahl; i++ )
-		{
-			if( !teams->z( i ) )
-				continue;
-			if( gemahlt->hat( i ) && gemahlt->get( i ) )
-				continue;
-			int p = teams->z( i )->getPunkte();
-			if( p > min )
-			{
-				min = p;
-				tmp = i;
-			}
-		}
-		if( tmp >= 0 )
-		{
-			gemahlt->set( 1, tmp );
-			teams->z( tmp )->render( yOff, zRObj );
-			yOff += teams->z( tmp )->getHeight();
-		}
-		else
-			break;
-	}
-	gemahlt->release();
-	zRObj.addScrollOffset( 0, -scroll->getScroll() );
-	scroll->update( yOff, rahmen->getHeight() - 2 );
-	scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
-	zRObj.releaseDrawOptions();
+    if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    rahmen->render( zRObj );
+    zRObj.addScrollOffset( 0, scroll->getScroll() );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    neuPunkte->render( zRObj );
+    status->render( zRObj );
+    int yOff = 20;
+    Array< bool > *gemahlt = new Array< bool >();
+    for( int i = 0; i < teamAnzahl; i++ )
+        gemahlt->set( 0, i );
+    int min = -1;
+    int tmp = -1;
+    for( int h = 0; h < teamAnzahl; h++ )
+    {
+        min = -1;
+        tmp = -1;
+        for( int i = 0; i < teamAnzahl; i++ )
+        {
+            if( !teams->z( i ) )
+                continue;
+            if( gemahlt->hat( i ) && gemahlt->get( i ) )
+                continue;
+            int p = teams->z( i )->getPunkte();
+            if( p > min )
+            {
+                min = p;
+                tmp = i;
+            }
+        }
+        if( tmp >= 0 )
+        {
+            gemahlt->set( 1, tmp );
+            teams->z( tmp )->render( yOff, zRObj );
+            yOff += teams->z( tmp )->getHeight();
+        }
+        else
+            break;
+    }
+    gemahlt->release();
+    zRObj.addScrollOffset( 0, -scroll->getScroll() );
+    scroll->update( yOff, rahmen->getHeight() - 2 );
+    scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int Bestenliste::getTeamAnzahl() const
 {
-	return teamAnzahl;
+    return teamAnzahl;
 }
 
 bool Bestenliste::teamExistiert( int team ) const
 {
-	return teams->z( team ) != 0;
+    return teams->z( team ) != 0;
 }
 
 int Bestenliste::getTeamPunkte( int team ) const
 {
-	return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
+    return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
 }
 
 // Reference Counting
 Bestenliste *Bestenliste::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Bestenliste *Bestenliste::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Spiel/Chat/Chat.cpp

@@ -11,134 +11,134 @@
 // Konstruktor
 SpielChat::SpielChat()
 {
-	rahmen = new LRahmen();
-	rahmen->setFarbe( 0xFF909090 );
-	rahmen->setRamenBreite( 1 );
-	rahmen->setSize( 450, 200 );
-	rahmen->setPosition( 10, BildschirmGröße().y - 210 );
-	verlauf = new TextFeld();
-	verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen ) );
-	verlauf->setText( "" );
-	verlauf->setSchriftFarbe( 0xFFFFFFFF );
-	verlauf->setSchriftSize( 12 );
-	verlauf->setPosition( rahmen->getX() + 2, rahmen->getY() + 2 );
-	verlauf->setSize( 446, 174 );
-	nachricht = new TextFeld();
-	nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
-	nachricht->setText( "" );
-	nachricht->setSchriftFarbe( 0xFF909090 );
-	nachricht->setSchriftSize( 12 );
-	nachricht->setRahmenBreite( 1 );
-	nachricht->setRahmenFarbe( 0xFF909090 );
-	nachricht->setPosition( rahmen->getX() + 2, rahmen->getY() + 178 );
-	nachricht->setSize( 446, 20 );
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setFarbe( 0xFF909090 );
+    rahmen->setRamenBreite( 1 );
+    rahmen->setSize( 450, 200 );
+    rahmen->setPosition( 10, BildschirmGröße().y - 210 );
+    verlauf = new TextFeld();
+    verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen ) );
+    verlauf->setText( "" );
+    verlauf->setSchriftFarbe( 0xFFFFFFFF );
+    verlauf->setSchriftSize( 12 );
+    verlauf->setPosition( rahmen->getX() + 2, rahmen->getY() + 2 );
+    verlauf->setSize( 446, 174 );
+    nachricht = new TextFeld();
+    nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
+    nachricht->setText( "" );
+    nachricht->setSchriftFarbe( 0xFF909090 );
+    nachricht->setSchriftSize( 12 );
+    nachricht->setRahmenBreite( 1 );
+    nachricht->setRahmenFarbe( 0xFF909090 );
+    nachricht->setPosition( rahmen->getX() + 2, rahmen->getY() + 178 );
+    nachricht->setSize( 446, 20 );
+    ref = 1;
 }
 
 // Destruktor
 SpielChat::~SpielChat()
 {
-	rahmen->release();
-	verlauf->release();
-	nachricht->release();
+    rahmen->release();
+    verlauf->release();
+    nachricht->release();
 }
 
 // nicht constant
 void SpielChat::setSchrift( Schrift *zSchrift )
 {
-	verlauf->setSchriftZ( zSchrift->getThis() );
-	nachricht->setSchriftZ( zSchrift->getThis() );
+    verlauf->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    nachricht->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
 }
 
 void SpielChat::addNachricht( char *nachricht )
 {
-	verlauf->addZeile( nachricht, 0xFFFFFFFF );
-	verlauf->updateVScroll();
+    verlauf->addZeile( nachricht, 0xFFFFFFFF );
+    verlauf->updateVScroll();
 }
 
 void SpielChat::addNachricht( char *nachricht, int farbe )
 {
-	verlauf->addZeile( nachricht, farbe );
-	verlauf->updateVScroll( );
+    verlauf->addZeile( nachricht, farbe );
+    verlauf->updateVScroll();
 }
 
 void SpielChat::doPublicMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	verlauf->doPublicMausEreignis( me );
-	nachricht->doPublicMausEreignis( me );
-	if( !vera && me.verarbeitet )
-	{
-		nachricht->setRahmenFarbe( 0xFFFFFFFF );
-		nachricht->setSchriftFarbe( 0xFFFFFFFF );
-		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
-		rahmen->setFarbe( 0xFFFFFFFF );
-	}
-	else
-	{
-		nachricht->setRahmenFarbe( 0xFF909090 );
-		nachricht->setSchriftFarbe( 0xFF909090 );
-		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
-		rahmen->setFarbe( 0xFF909090 );
-	}
+    bool vera = me.verarbeitet;
+    verlauf->doPublicMausEreignis( me );
+    nachricht->doPublicMausEreignis( me );
+    if( !vera && me.verarbeitet )
+    {
+        nachricht->setRahmenFarbe( 0xFFFFFFFF );
+        nachricht->setSchriftFarbe( 0xFFFFFFFF );
+        verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+        rahmen->setFarbe( 0xFFFFFFFF );
+    }
+    else
+    {
+        nachricht->setRahmenFarbe( 0xFF909090 );
+        nachricht->setSchriftFarbe( 0xFF909090 );
+        verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+        rahmen->setFarbe( 0xFF909090 );
+    }
 }
 
 void SpielChat::doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient )
 {
-	if( te.id == TE_Release && te.taste == T_Enter && !te.verarbeitet )
-	{
-		if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
-		{
-			if( nachricht->zText()->getLength() )
-			{
-				short län = 1 + nachricht->zText()->getLength();
-				char *bytes = new char[ län + 1 ];
-				*bytes = 4;
-				for( int i = 1; i <= län; i++ )
-					bytes[ i ] = nachricht->zText()->getText()[ i - 1 ];
-				nachricht->setText( "" );
-				nachricht->setAuswahl( 0, 0 );
-				nachricht->removeStyle( TextFeld::Style::Fokus );
-				zKlient->spielNachricht( län, bytes );
-				delete[] bytes;
-				te.verarbeitet = 1;
-			}
-		}
-		else
-		{
-			nachricht->addStyle( TextFeld::Style::Fokus );
-			nachricht->setAuswahl( 0, nachricht->zText()->getLength() );
-			te.verarbeitet = 1;
-		}
-	}
-	if( !te.verarbeitet )
-		nachricht->doTastaturEreignis( te );
-	if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
-	{
-		nachricht->setRahmenFarbe( 0xFFFFFFFF );
-		nachricht->setSchriftFarbe( 0xFFFFFFFF );
-		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
-		rahmen->setFarbe( 0xFFFFFFFF );
-	}
-	else
-	{
-		nachricht->setRahmenFarbe( 0xFF909090 );
-		nachricht->setSchriftFarbe( 0xFF909090 );
-		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
-		rahmen->setFarbe( 0xFF909090 );
-	}
+    if( te.id == TE_Release && te.taste == T_Enter && !te.verarbeitet )
+    {
+        if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+        {
+            if( nachricht->zText()->getLength() )
+            {
+                short län = 1 + nachricht->zText()->getLength();
+                char *bytes = new char[ län + 1 ];
+                *bytes = 4;
+                for( int i = 1; i <= län; i++ )
+                    bytes[ i ] = nachricht->zText()->getText()[ i - 1 ];
+                nachricht->setText( "" );
+                nachricht->setAuswahl( 0, 0 );
+                nachricht->removeStyle( TextFeld::Style::Fokus );
+                zKlient->spielNachricht( län, bytes );
+                delete[] bytes;
+                te.verarbeitet = 1;
+            }
+        }
+        else
+        {
+            nachricht->addStyle( TextFeld::Style::Fokus );
+            nachricht->setAuswahl( 0, nachricht->zText()->getLength() );
+            te.verarbeitet = 1;
+        }
+    }
+    if( !te.verarbeitet )
+        nachricht->doTastaturEreignis( te );
+    if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+    {
+        nachricht->setRahmenFarbe( 0xFFFFFFFF );
+        nachricht->setSchriftFarbe( 0xFFFFFFFF );
+        verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+        rahmen->setFarbe( 0xFFFFFFFF );
+    }
+    else
+    {
+        nachricht->setRahmenFarbe( 0xFF909090 );
+        nachricht->setSchriftFarbe( 0xFF909090 );
+        verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+        rahmen->setFarbe( 0xFF909090 );
+    }
 }
 
 void SpielChat::tick( double z )
 {
-	nachricht->tick( z );
+    nachricht->tick( z );
 }
 
 void SpielChat::render( Bild &zRObj )
 {
-	rahmen->render( zRObj );
-	verlauf->render( zRObj );
-	nachricht->render( zRObj );
+    rahmen->render( zRObj );
+    verlauf->render( zRObj );
+    nachricht->render( zRObj );
 }
 
 // constant
@@ -146,14 +146,14 @@ void SpielChat::render( Bild &zRObj )
 // Reference Counting
 SpielChat *SpielChat::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 SpielChat *SpielChat::relese()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Spiel/Ende/Ende.cpp

@@ -9,103 +9,103 @@
 // Konstruktor
 Ende::Ende( Schrift *zSchrift )
 {
-	rahmen = new LRahmen();
-	rahmen->setSize( 200, 100 );
-	rahmen->setRamenBreite( 2 );
-	rahmen->setFarbe( 0xFFFFFFFF );
-	text = new TextFeld();
-	text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
-	text->setSchriftZ( zSchrift->getThis() );
-	text->setText( "" );
-	text->setSchriftFarbe( 0xFFFFFFFF );
-	text->setSize( 200, 50 );
-	warten = new TextFeld();
-	warten->setStyle( ( TextFeld::Style::Text | TextFeld::Style::Center ) & ~TextFeld::Style::Sichtbar );
-	warten->setSchriftZ( zSchrift->getThis() );
-	warten->setText( "Bitte warten..." );
-	warten->setSchriftFarbe( 0xFFFFFFFF );
-	warten->setSize( 200, 50 );
-	ok = new Knopf( );
-	ok->setStyle( Knopf::Style::Normal );
-	ok->setSize( 100, 20 );
-	ok->setText( "Weiter" );
-	ok->setSchriftZ( zSchrift->getThis() );
-	weiter = 0;
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setSize( 200, 100 );
+    rahmen->setRamenBreite( 2 );
+    rahmen->setFarbe( 0xFFFFFFFF );
+    text = new TextFeld();
+    text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
+    text->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    text->setText( "" );
+    text->setSchriftFarbe( 0xFFFFFFFF );
+    text->setSize( 200, 50 );
+    warten = new TextFeld();
+    warten->setStyle( ( TextFeld::Style::Text | TextFeld::Style::Center ) & ~TextFeld::Style::Sichtbar );
+    warten->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    warten->setText( "Bitte warten..." );
+    warten->setSchriftFarbe( 0xFFFFFFFF );
+    warten->setSize( 200, 50 );
+    ok = new Knopf();
+    ok->setStyle( Knopf::Style::Normal );
+    ok->setSize( 100, 20 );
+    ok->setText( "Weiter" );
+    ok->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    weiter = 0;
+    ref = 1;
 }
 
 // Destruktor
 Ende::~Ende()
 {
-	rahmen->release();
-	text->release();
-	warten->release();
-	ok->release();
+    rahmen->release();
+    text->release();
+    warten->release();
+    ok->release();
 }
 
 // nicht constant
 void Ende::setGewonnen( char gewonnen )
 {
-	if( gewonnen == 1 )
-	{
-		text->setText( "Du hast gewonnen." );
-		text->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else if( !gewonnen )
-	{
-		text->setText( "Du hast verloren." );
-		text->setSchriftFarbe( 0xFFFF0000 );
-	}
-	else
-	{
-		text->setText( "Unentschieden." );
-		text->setSchriftFarbe( 0xFFFFFFFF );
-	}
+    if( gewonnen == 1 )
+    {
+        text->setText( "Du hast gewonnen." );
+        text->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else if( !gewonnen )
+    {
+        text->setText( "Du hast verloren." );
+        text->setSchriftFarbe( 0xFFFF0000 );
+    }
+    else
+    {
+        text->setText( "Unentschieden." );
+        text->setSchriftFarbe( 0xFFFFFFFF );
+    }
 }
 
 void Ende::doPublicMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	ok->doPublicMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-	{
-		ok->removeStyle( Knopf::Style::Sichtbar );
-		warten->addStyle( TextFeld::Style::Sichtbar );
-		weiter = 1;
-	}
-	me.verarbeitet = 1;
+    bool vera = me.verarbeitet;
+    ok->doPublicMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+    {
+        ok->removeStyle( Knopf::Style::Sichtbar );
+        warten->addStyle( TextFeld::Style::Sichtbar );
+        weiter = 1;
+    }
+    me.verarbeitet = 1;
 }
 
 void Ende::render( Bild &zRObj )
 {
-	rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
-	zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
-	rahmen->render( zRObj );
-	text->setPosition( rahmen->getX(), rahmen->getY() );
-	text->render( zRObj );
-	warten->setPosition( rahmen->getX(), rahmen->getY() + 50 );
-	warten->render( zRObj );
-	ok->setPosition( rahmen->getX() + rahmen->getBreite() / 2 - ok->getBreite() / 2, rahmen->getY() + 65 );
-	ok->render( zRObj );
+    rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
+    zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
+    rahmen->render( zRObj );
+    text->setPosition( rahmen->getX(), rahmen->getY() );
+    text->render( zRObj );
+    warten->setPosition( rahmen->getX(), rahmen->getY() + 50 );
+    warten->render( zRObj );
+    ok->setPosition( rahmen->getX() + rahmen->getBreite() / 2 - ok->getBreite() / 2, rahmen->getY() + 65 );
+    ok->render( zRObj );
 }
 
 // constant
 bool Ende::getWeiter() const
 {
-	return weiter;
+    return weiter;
 }
 
 // Reference Counting
 Ende *Ende::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Ende *Ende::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Spiel/Ende/RundenEnde.cpp

@@ -9,91 +9,91 @@
 // Konstruktor
 RundenEnde::RundenEnde( Schrift *zSchrift )
 {
-	rahmen = new LRahmen();
-	rahmen->setSize( 220, 70 );
-	rahmen->setRamenBreite( 2 );
-	rahmen->setFarbe( 0xFFFFFFFF );
-	text = new TextFeld();
-	text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
-	text->setSchriftZ( zSchrift->getThis() );
-	text->setText( "" );
-	text->setSchriftFarbe( 0xFFFFFFFF );
-	text->setSize( 220, 50 );
-	warten = new TextFeld();
-	warten->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
-	warten->setSchriftZ( zSchrift->getThis() );
-	warten->setText( "Nächste Runde startet in: 5" );
-	warten->setSchriftFarbe( 0xFFFFFFFF );
-	warten->setSize( 220, 45 );
-	sichtbar = 0;
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setSize( 220, 70 );
+    rahmen->setRamenBreite( 2 );
+    rahmen->setFarbe( 0xFFFFFFFF );
+    text = new TextFeld();
+    text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
+    text->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    text->setText( "" );
+    text->setSchriftFarbe( 0xFFFFFFFF );
+    text->setSize( 220, 50 );
+    warten = new TextFeld();
+    warten->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
+    warten->setSchriftZ( dynamic_cast<Schrift *>( zSchrift->getThis() ) );
+    warten->setText( "Nächste Runde startet in: 5" );
+    warten->setSchriftFarbe( 0xFFFFFFFF );
+    warten->setSize( 220, 45 );
+    sichtbar = 0;
+    ref = 1;
 }
 
 // Destruktor
 RundenEnde::~RundenEnde()
 {
-	rahmen->release();
-	text->release();
-	warten->release();
+    rahmen->release();
+    text->release();
+    warten->release();
 }
 
 // nicht constant
 void RundenEnde::setSichtbar( bool b )
 {
-	sichtbar = b;
+    sichtbar = b;
 }
 
 void RundenEnde::setGewonnen( bool gewonnen )
 {
-	if( gewonnen )
-	{
-		text->setText( "Du hast die Runde gewonnen." );
-		text->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else
-	{
-		text->setText( "Du hast die Runde verloren." );
-		text->setSchriftFarbe( 0xFFFF0000 );
-	}
+    if( gewonnen )
+    {
+        text->setText( "Du hast die Runde gewonnen." );
+        text->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else
+    {
+        text->setText( "Du hast die Runde verloren." );
+        text->setSchriftFarbe( 0xFFFF0000 );
+    }
 }
 
 void RundenEnde::setZeit( int sekunden )
 {
-	warten->setText( "Nächste Runde startet in: " );
-	warten->zText()->append( sekunden );
+    warten->setText( "Nächste Runde startet in: " );
+    warten->zText()->append( sekunden );
 }
 
 void RundenEnde::render( Bild &zRObj )
 {
-	if( sichtbar )
-	{
-		rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
-		zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
-		rahmen->render( zRObj );
-		text->setPosition( rahmen->getX(), rahmen->getY() );
-		text->render( zRObj );
-		warten->setPosition( rahmen->getX(), rahmen->getY() + 25 );
-		warten->render( zRObj );
-	}
+    if( sichtbar )
+    {
+        rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
+        zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
+        rahmen->render( zRObj );
+        text->setPosition( rahmen->getX(), rahmen->getY() );
+        text->render( zRObj );
+        warten->setPosition( rahmen->getX(), rahmen->getY() + 25 );
+        warten->render( zRObj );
+    }
 }
 
 // constant
 bool RundenEnde::istSichtbar() const
 {
-	return sichtbar;
+    return sichtbar;
 }
 
 // Reference Counting
 RundenEnde *RundenEnde::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 RundenEnde *RundenEnde::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Spiel/SpielKlasse.cpp

@@ -8,811 +8,811 @@
 // Konstruktor
 SpielKlasse::SpielKlasse()
 {
-	spielZeit = 0;
-	rZeit = 0;
-	spielPause = 1;
-	rendern = 0;
-	stkn = new RCArray< STKNachricht >();
-	stkna = 0;
-	schrift = 0;
-	time_t t;
-	time( &t );
-	srand( (unsigned int)t );
-	infoKlient = 0;
-	spielKlient = 0;
-	spieler = new RCArray< Spieler >();
-	screen = 0;
-	kam = 0;
-	spielerAnzahl = 0;
-	karteId = 0;
-	spielerNummer = 0;
-	map = 0;
-	rEnd = 0;
-	end = 0;
-	chat = new SpielChat();
-	tasten = new char[ 256 ];
-	for( int i = 0; i < 256; i++ )
-		tasten[ i ] = 0;
-	mx = -1;
-	my = -1;
-	bestenliste = 0;
-	ref = 1;
+    spielZeit = 0;
+    rZeit = 0;
+    spielPause = 1;
+    rendern = 0;
+    stkn = new RCArray< STKNachricht >();
+    stkna = 0;
+    schrift = 0;
+    time_t t;
+    time( &t );
+    srand( (unsigned int)t );
+    infoKlient = 0;
+    spielKlient = 0;
+    spieler = new RCArray< Spieler >();
+    screen = 0;
+    kam = 0;
+    spielerAnzahl = 0;
+    karteId = 0;
+    spielerNummer = 0;
+    map = 0;
+    rEnd = 0;
+    end = 0;
+    chat = new SpielChat();
+    tasten = new char[ 256 ];
+    for( int i = 0; i < 256; i++ )
+        tasten[ i ] = 0;
+    mx = -1;
+    my = -1;
+    bestenliste = 0;
+    ref = 1;
 }
 
 // Destruktor
 SpielKlasse::~SpielKlasse()
 {
-	stkn->release();
-	if( schrift )
-		schrift->release();
-	if( infoKlient )
-		infoKlient->release();
-	if( spielKlient )
-		spielKlient->release();
-	if( kam )
-		kam->release();
-	if( map )
-		map->release();
-	if( rEnd )
-		rEnd->release();
-	if( end )
-		end->release();
-	if( bestenliste )
-		bestenliste->release();
-	chat->relese();
-	spieler->release();
-	delete[] tasten;
+    stkn->release();
+    if( schrift )
+        schrift->release();
+    if( infoKlient )
+        infoKlient->release();
+    if( spielKlient )
+        spielKlient->release();
+    if( kam )
+        kam->release();
+    if( map )
+        map->release();
+    if( rEnd )
+        rEnd->release();
+    if( end )
+        end->release();
+    if( bestenliste )
+        bestenliste->release();
+    chat->relese();
+    spieler->release();
+    delete[] tasten;
 }
 
 // privat
 bool SpielKlasse::istAmLeben() const
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-			return spieler->z( i )->istAmLeben();
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+            return spieler->z( i )->istAmLeben();
+    }
+    return 0;
 }
 
 // nicht constant
 void SpielKlasse::lock()
 {
-	if( screen )
-		screen->lock();
+    if( screen )
+        screen->lock();
 }
 
 void SpielKlasse::unlock()
 {
-	if( screen )
-		screen->unlock();
+    if( screen )
+        screen->unlock();
 }
 
 void SpielKlasse::setSchrift( Schrift *schrift )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
-	chat->setSchrift( schrift );
-	if( !bestenliste )
-		bestenliste = new Bestenliste( schrift->getThis() );
-	if( !rEnd )
-		rEnd = new RundenEnde( schrift );
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
+    chat->setSchrift( schrift );
+    if( !bestenliste )
+        bestenliste = new Bestenliste( dynamic_cast<Schrift *>( schrift->getThis() ) );
+    if( !rEnd )
+        rEnd = new RundenEnde( schrift );
 }
 
 void SpielKlasse::setBildschirm( Bildschirm *zScreen )
 {
-	screen = zScreen;
+    screen = zScreen;
 }
 
 void SpielKlasse::nachricht( int län, char *bytes )
 {
-	if( !län )
-		return;
-	lock();
-	stkn->add( new STKNachricht( län, bytes ), stkna );
-	stkna++;
-	unlock();
+    if( !län )
+        return;
+    lock();
+    stkn->add( new STKNachricht( län, bytes ), stkna );
+    stkna++;
+    unlock();
 }
 
 void SpielKlasse::setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient )
 {
-	if( this->infoKlient )
-		this->infoKlient->release();
-	this->infoKlient = infoKlient;
-	if( this->spielKlient )
-		this->spielKlient->release();
-	this->spielKlient = spielKlient;
+    if( this->infoKlient )
+        this->infoKlient->release();
+    this->infoKlient = infoKlient;
+    if( this->spielKlient )
+        this->spielKlient->release();
+    this->spielKlient = spielKlient;
 }
 
 void SpielKlasse::setKarteId( int karteId )
 {
-	this->karteId = karteId;
+    this->karteId = karteId;
 }
 
 void SpielKlasse::ladeDaten()
 {
-	kam = new Kamera();
-	kam->setSize( 400, 400 );
-	map = new Karte();
-	map->setId( karteId );
-	for( int i = 1; i <= 100; i++ )
-	{
-		Sleep( 100 + ( rand() % 100 ) );
-		spielKlient->setLadenProzent( i );
-	}
+    kam = new Kamera();
+    kam->setSize( 400, 400 );
+    map = new Karte();
+    map->setId( karteId );
+    for( int i = 1; i <= 100; i++ )
+    {
+        Sleep( 100 + ( rand() % 100 ) );
+        spielKlient->setLadenProzent( i );
+    }
 }
 
 void SpielKlasse::doPublicMausEreignis( MausEreignis &me )
 {
-	if( end )
-	{
-		end->doPublicMausEreignis( me );
-		return;
-	}
-	if( !istAmLeben() && kam->istMausIn( me.mx, me.my ) )
-	{
-		if( ( me.id == ME_RLinks || me.id == ME_RRechts ) && mx >= 0 )
-		{
-			mx = -1;
-			my = -1;
-		}
-		if( me.id == ME_Bewegung && mx >= 0 )
-		{
-			kam->addPosition( mx - me.mx, my - me.my, map );
-			mx = me.mx;
-			my = me.my;
-		}
-		if( ( me.id == ME_PLinks || me.id == ME_PRechts ) && mx < 0 )
-		{
-			mx = me.mx;
-			my = me.my;
-		}
-		me.verarbeitet = 1;
-	}
-	else
-	{
-		mx = -1;
-		my = -1;
-	}
-	chat->doPublicMausEreignis( me );
-	if( bestenliste )
-		bestenliste->doPublicMausEreignis( me );
+    if( end )
+    {
+        end->doPublicMausEreignis( me );
+        return;
+    }
+    if( !istAmLeben() && kam->istMausIn( me.mx, me.my ) )
+    {
+        if( ( me.id == ME_RLinks || me.id == ME_RRechts ) && mx >= 0 )
+        {
+            mx = -1;
+            my = -1;
+        }
+        if( me.id == ME_Bewegung && mx >= 0 )
+        {
+            kam->addPosition( mx - me.mx, my - me.my, map );
+            mx = me.mx;
+            my = me.my;
+        }
+        if( ( me.id == ME_PLinks || me.id == ME_PRechts ) && mx < 0 )
+        {
+            mx = me.mx;
+            my = me.my;
+        }
+        me.verarbeitet = 1;
+    }
+    else
+    {
+        mx = -1;
+        my = -1;
+    }
+    chat->doPublicMausEreignis( me );
+    if( bestenliste )
+        bestenliste->doPublicMausEreignis( me );
 }
 
 void SpielKlasse::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( end )
-		return;
-	if( istAmLeben() )
-	{
-		if( te.id == TE_Press )
-		{
-			switch( te.taste )
-			{
-			case T_Links:
-				if( !tasten[ T_Links ] )
-				{
-					tasten[ T_Links ] = 1;
-					char byte = 0;
-					spielKlient->spielNachricht( 1, &byte );
-					te.verarbeitet = 1;
-				}
-				break;
-			case T_Rechts:
-				if( !tasten[ T_Rechts ] )
-				{
-					tasten[ T_Rechts ] = 1;
-					char byte = 2;
-					spielKlient->spielNachricht( 1, &byte );
-					te.verarbeitet = 1;
-				}
-				break;
-			}
-		}
-		if( te.id == TE_Release )
-		{
-			switch( te.taste )
-			{
-			case T_Links:
-				if( tasten[ T_Links ] )
-				{
-					tasten[ T_Links ] = 0;
-					char byte = 1;
-					spielKlient->spielNachricht( 1, &byte );
-					te.verarbeitet = 1;
-				}
-				break;
-			case T_Rechts:
-				if( tasten[ T_Rechts ] )
-				{
-					tasten[ T_Rechts ] = 0;
-					char byte = 3;
-					spielKlient->spielNachricht( 1, &byte );
-					te.verarbeitet = 1;
-				}
-				break;
-			}
-		}
-	}
-	else
-	{
-		if( te.id == TE_Press )
-		{
-			switch( te.taste )
-			{
-			case T_Links:
-				kam->addPosition( -2, 0, map );
-				te.verarbeitet = 1;
-				break;
-			case T_Oben:
-				kam->addPosition( 0, -2, map );
-				te.verarbeitet = 1;
-				break;
-			case T_Rechts:
-				kam->addPosition( 2, 0, map );
-				te.verarbeitet = 1;
-				break;
-			case T_Unten:
-				kam->addPosition( 0, 2, map );
-				te.verarbeitet = 1;
-				break;
-			}
-		}
-	}
-	if( !te.verarbeitet )
-		chat->doTastaturEreignis( te, spielKlient );
+    if( end )
+        return;
+    if( istAmLeben() )
+    {
+        if( te.id == TE_Press )
+        {
+            switch( te.taste )
+            {
+            case T_Links:
+                if( !tasten[ T_Links ] )
+                {
+                    tasten[ T_Links ] = 1;
+                    char byte = 0;
+                    spielKlient->spielNachricht( 1, &byte );
+                    te.verarbeitet = 1;
+                }
+                break;
+            case T_Rechts:
+                if( !tasten[ T_Rechts ] )
+                {
+                    tasten[ T_Rechts ] = 1;
+                    char byte = 2;
+                    spielKlient->spielNachricht( 1, &byte );
+                    te.verarbeitet = 1;
+                }
+                break;
+            }
+        }
+        if( te.id == TE_Release )
+        {
+            switch( te.taste )
+            {
+            case T_Links:
+                if( tasten[ T_Links ] )
+                {
+                    tasten[ T_Links ] = 0;
+                    char byte = 1;
+                    spielKlient->spielNachricht( 1, &byte );
+                    te.verarbeitet = 1;
+                }
+                break;
+            case T_Rechts:
+                if( tasten[ T_Rechts ] )
+                {
+                    tasten[ T_Rechts ] = 0;
+                    char byte = 3;
+                    spielKlient->spielNachricht( 1, &byte );
+                    te.verarbeitet = 1;
+                }
+                break;
+            }
+        }
+    }
+    else
+    {
+        if( te.id == TE_Press )
+        {
+            switch( te.taste )
+            {
+            case T_Links:
+                kam->addPosition( -2, 0, map );
+                te.verarbeitet = 1;
+                break;
+            case T_Oben:
+                kam->addPosition( 0, -2, map );
+                te.verarbeitet = 1;
+                break;
+            case T_Rechts:
+                kam->addPosition( 2, 0, map );
+                te.verarbeitet = 1;
+                break;
+            case T_Unten:
+                kam->addPosition( 0, 2, map );
+                te.verarbeitet = 1;
+                break;
+            }
+        }
+    }
+    if( !te.verarbeitet )
+        chat->doTastaturEreignis( te, spielKlient );
 }
 
 void SpielKlasse::stknVerarbeitung()
 {
-	lock();
-	for( int i = 0; i < stkna; i++ )
-	{
-		STKNachricht *n = stkn->z( i );
-		double zeit = n->getSpielZeit();
-		if( zeit > spielZeit && ( !rEnd || !rEnd->istSichtbar() ) )
-			break;
-		int län = n->getLength();
-		char *bytes = n->getNachricht();
-		län--;
-		switch( bytes[ 0 ] )
-		{
-		case 0: // set Spieler Nummer
-			bytes++;
-			spielerNummer = *(int*)bytes;
-			län -= 4;
-			break;
-		case 1: // init Spieler
-			if( 1 )
-			{
-				bytes++;
-				spielerAnzahl = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				int maxTeam = 0;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					Spieler *tmp = new Spieler( infoKlient );
-					int sNum = *(int*)bytes;
-					län -= 4;
-					bytes += 4;
-					tmp->setSpielerNummer( sNum );
-					int team = *(int*)bytes;
-					län -= 4;
-					bytes += 4;
-					maxTeam = maxTeam < team ? team : maxTeam;
-					tmp->setTeam( team );
-					int sFarbe = *(int*)bytes;
-					län -= 4;
-					bytes += 4;
-					tmp->setSpielerFarbe( sFarbe );
-					int tFarbe = *(int*)bytes;
-					län -= 4;
-					bytes += 4;
-					tmp->setTeamFarbe( tFarbe );
-					int accId = *(int*)bytes;
-					län -= 4;
-					bytes += 4;
-					tmp->setAccountId( accId );
-					bestenliste->addSpieler( tmp );
-					bestenliste->updateSpielerStatus( tmp );
-					spieler->set( tmp, i );
-				}
-				bestenliste->setTeamAnzahl( maxTeam + 1 );
-			}
-			break;
-		case 2: // setze Spieler Position
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				double posX = *(double*)bytes;
-				län -= 8;
-				bytes += 8;
-				double posY = *(double*)bytes;
-				län -= 8;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == sNum )
-						spieler->z( i )->setPos( posX, posY );
-				}
-				if( spielerNummer == sNum )
-					kam->setPosition( (int)posX, (int)posY );
-			}
-			break;
-		case 3: // setzt kammera größe
-			if( 1 )
-			{
-				bytes++;
-				int br = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				int hö = *(int*)bytes;
-				län -= 4;
-				kam->setSize( br, hö );
-			}
-			break;
-		case 4: // Zeit Beginn
-			spielPause = 0;
-			spielZeit = 0;
-			rZeit = 0;
-			rendern = 1;
-			break;
-		case 5: // spieler ist tod
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				Text *zName = 0;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					int team = spieler->z( i )->getTeam();
-					int player = spieler->z( i )->getSpielerNummer();
-					if( player == sNum )
-					{
-						spieler->z( i )->sterben( map->zMap(), zeit, spielZeit );
-						bestenliste->updateSpielerStatus( spieler->z( i ) );
-						zName = spieler->z( i )->zName();
-						bool teamLebt = 0;
-						for( int j = 0; j < spielerAnzahl; j++ )
-						{
-							if( spieler->z( j ) && spieler->z( j )->getTeam() == team )
-								teamLebt |= spieler->z( j )->istAmLeben();
-						}
-						if( !teamLebt )
-						{
-							for( int j = 0; j < bestenliste->getTeamAnzahl(); j++ )
-							{
-								if( bestenliste->teamExistiert( j ) )
-								{
-									bool amLeben = 0;
-									for( int k = 0; k < spielerAnzahl; k++ )
-									{
-										if( spieler->z( k ) && spieler->z( k )->getTeam() == j )
-											amLeben |= spieler->z( k )->istAmLeben();
-									}
-									if( amLeben )
-										bestenliste->addPunkt( j, 1 );
-									else
-										bestenliste->addPunkt( j, 0 );
-									if( bestenliste->getTeamPunkte( j ) <= 0 )
-										bestenliste->setTeamStatus( j, "tot", 0xFFFF0000 );
-								}
-							}
-						}
-					}
-					else
-					{
-						if( spieler->z( i )->istAmLeben() )
-							bestenliste->addPunkt( team, player, 1 );
-					}
-				}
-				if( sNum == spielerNummer )
-					chat->addNachricht( "Du bist gestorben.", 0xFFFFFF00 );
-				else if( zName )
-				{
-					Text *txt = new Text( zName->getText() );
-					txt->append( " ist gestorben." );
-					chat->addNachricht( txt->getText(), 0xFFFFFF00 );
-					txt->release();
-				}
-			}
-			break;
-		case 6: // spiel Ende
-			if( 1 )
-			{
-				bestenliste->updatePunkte();
-				bytes++;
-				char gewonnen = *bytes;
-				län--;
-				end = new Ende( schrift );
-				end->setGewonnen( gewonnen );
-			}
-			break;
-		case 7: // set Spieler Geschwindigkeit
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				double xSpeed = *(double*)bytes;
-				län -= 8;
-				bytes += 8;
-				double ySpeed = *(double*)bytes;
-				län -= 8;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == sNum )
-						spieler->z( i )->setSpeed( xSpeed, ySpeed );
-				}
-			}
-			break;
-		case 8: // set Spieler Wendigkeit
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				double kurve = *(double*)bytes;
-				län -= 8;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == sNum )
-						spieler->z( i )->setKurveSpeed( kurve );
-				}
-			}
-			break;
-		case 9: // set Spieler Kurve
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				char k = *bytes;
-				län--;
-				if( k == 0 )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == sNum )
-						{
-							spieler->z( i )->setLinksKurve( map->zMap(), 0, zeit, spielZeit );
-							spieler->z( i )->setRechtsKurve( map->zMap(), 0, zeit, spielZeit );
-						}
-					}
-				}
-				else if( k == 1 )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == sNum )
-							spieler->z( i )->setLinksKurve( map->zMap(), 1, zeit, spielZeit );
-					}
-				}
-				else if( k == 2 )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == sNum )
-							spieler->z( i )->setLinksKurve( map->zMap(), 0, zeit, spielZeit );
-					}
-				}
-				else if( k == 3 )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == sNum )
-							spieler->z( i )->setRechtsKurve( map->zMap(), 1, zeit, spielZeit );
-					}
-				}
-				else if( k == 4 )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == sNum )
-							spieler->z( i )->setRechtsKurve( map->zMap(), 0, zeit, spielZeit );
-					}
-				}
-				else if( k == 5 )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == sNum )
-						{
-							spieler->z( i )->setLinksKurve( map->zMap(), 1, zeit, spielZeit );
-							spieler->z( i )->setRechtsKurve( map->zMap(), 1, zeit, spielZeit );
-						}
-					}
-				}
-			}
-			break;
-		case 0xA: // set Karte Größe
-			if( 1 )
-			{
-				bytes++;
-				int br = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				int hö = *(int*)bytes;
-				län -= 4;
-				map->setSize( br, hö );
-			}
-			break;
-		case 0xB: // chat Nachricht
-			if( 1 )
-			{
-				bytes++;
-				Text *txt = new Text( "" );
-				txt->append( bytes, län );
-				chat->addNachricht( txt->getText() );
-				txt->release();
-				län = 0;
-			}
-			break;
-		case 0xC: // Spieler Linien Unterbrechung
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				char unterbrechung = *bytes;
-				län--;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					Spieler *tmp = spieler->z( i );
-					if( tmp && tmp->getSpielerNummer() == sNum )
-						tmp->setLinienUnterbrechung( map->zMap(), unterbrechung != 0, zeit, spielZeit );
-				}
-			}
-			break;
-		case 0xD: // Max Team Punkte 
-			if( 1 )
-			{
-				bytes++;
-				int team = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				int mP = *(int*)bytes;
-				län -= 4;
-				bestenliste->setTeamMaxPunkte( team, mP );
-			}
-			break;
-		case 0xE: // Team Punkte
-			if( 1 )
-			{
-				bytes++;
-				int team = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				int p = *(int*)bytes;
-				län -= 4;
-				bestenliste->setTeamPunkte( team, p );
-				if( !p )
-					bestenliste->setTeamStatus( team, "tot", 0xFFFF0000 );
-			}
-			break;
-		case 0xF: // Spieler Punkte
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				int p = *(int*)bytes;
-				län -= 4;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i ) && spieler->z( i )->getSpielerNummer() == sNum )
-					{
-						bestenliste->setSpielerPunkte( spieler->z( i )->getTeam(), sNum, p );
-						break;
-					}
-				}
-			}
-			break;
-		case 0x10: // Team Tod
-			if( 1 )
-			{
-				bytes++;
-				int team = *(int*)bytes;
-				län -= 4;
-				bestenliste->setTeamPunkte( team, 0 );
-				bestenliste->setTeamStatus( team, "tot", 0xFFFF0000 );
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i ) && spieler->z( i )->getTeam() == team )
-					{
-						spieler->z( i )->sterben();
-						bestenliste->updateSpielerStatus( spieler->z( i ) );
-					}
-				}
-			}
-			break;
-		case 0x11: // Runden Ende
-			if( 1 )
-			{
-				spielPause = 1;
-				bytes++;
-				int team = *(int*)bytes;
-				län -= 4;
-				bool gewonnen = 0;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-					{
-						gewonnen = spieler->z( i )->getTeam() == team;
-						break;
-					}
-				}
-				rEnd->setGewonnen( gewonnen );
-				bestenliste->updatePunkte();
-				rEnd->setSichtbar( 1 );
-			}
-			break;
-		case 0x12: // Verbleibende Zeit
-			if( 1 )
-			{
-				bytes++;
-				int sek = *(int*)bytes;
-				län -= 4;
-				rEnd->setZeit( sek );
-				if( !sek )
-				{
-					if( rEnd && rEnd->istSichtbar() )
-					{
-						rEnd->setSichtbar( 0 );
-						rEnd->setZeit( 6 );
-						for( int i = 0; i < spielerAnzahl; i++ )
-						{
-							if( spieler->z( i ) )
-							{
-								spieler->z( i )->neuRunde();
-								if( !bestenliste->getTeamPunkte( spieler->z( i )->getTeam() ) )
-									spieler->z( i )->sterben();
-								bestenliste->updateSpielerStatus( spieler->z( i ) );
-							}
-						}
-					}
-				}
-			}
-			break;
-		case 0x13: // Team Name
-			if( 1 )
-			{
-				bytes++;
-				int team = *(int*)bytes;
-				län -= 4;
-				bytes += 4;
-				char *n = new char[ län + 1 ];
-				n[ län ] = 0;
-				memcpy( n, bytes, län );
-				län -= län;
-				bestenliste->setTeamName( team, n );
-				delete[] n;
-			}
-			break;
-		default:
-			// Fehler beim verarbeiten
-			break;
-		}
-		if( län != 0 )
-		{
-			// Fehler beim verarbeiten
-			chat->addNachricht( "Es ist ein Fehler beim verarbeiten einer Nachricht aufgetreten.", 0xFFFF0000 );
-		}
-		n->setVerarbeitet();
-	}
-	for( int i = stkna; i > 0; i-- )
-	{
-		if( !stkn->z( 0 ) || !stkn->z( 0 )->istVerarbeitet() )
-			break;
-		stkna--;
-		stkn->remove( 0 );
-	}
-	unlock();
+    lock();
+    for( int i = 0; i < stkna; i++ )
+    {
+        STKNachricht *n = stkn->z( i );
+        double zeit = n->getSpielZeit();
+        if( zeit > spielZeit && ( !rEnd || !rEnd->istSichtbar() ) )
+            break;
+        int län = n->getLength();
+        char *bytes = n->getNachricht();
+        län--;
+        switch( bytes[ 0 ] )
+        {
+        case 0: // set Spieler Nummer
+            bytes++;
+            spielerNummer = *(int *)bytes;
+            län -= 4;
+            break;
+        case 1: // init Spieler
+            if( 1 )
+            {
+                bytes++;
+                spielerAnzahl = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                int maxTeam = 0;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    Spieler *tmp = new Spieler( infoKlient );
+                    int sNum = *(int *)bytes;
+                    län -= 4;
+                    bytes += 4;
+                    tmp->setSpielerNummer( sNum );
+                    int team = *(int *)bytes;
+                    län -= 4;
+                    bytes += 4;
+                    maxTeam = maxTeam < team ? team : maxTeam;
+                    tmp->setTeam( team );
+                    int sFarbe = *(int *)bytes;
+                    län -= 4;
+                    bytes += 4;
+                    tmp->setSpielerFarbe( sFarbe );
+                    int tFarbe = *(int *)bytes;
+                    län -= 4;
+                    bytes += 4;
+                    tmp->setTeamFarbe( tFarbe );
+                    int accId = *(int *)bytes;
+                    län -= 4;
+                    bytes += 4;
+                    tmp->setAccountId( accId );
+                    bestenliste->addSpieler( tmp );
+                    bestenliste->updateSpielerStatus( tmp );
+                    spieler->set( tmp, i );
+                }
+                bestenliste->setTeamAnzahl( maxTeam + 1 );
+            }
+            break;
+        case 2: // setze Spieler Position
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                double posX = *(double *)bytes;
+                län -= 8;
+                bytes += 8;
+                double posY = *(double *)bytes;
+                län -= 8;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == sNum )
+                        spieler->z( i )->setPos( posX, posY );
+                }
+                if( spielerNummer == sNum )
+                    kam->setPosition( (int)posX, (int)posY );
+            }
+            break;
+        case 3: // setzt kammera größe
+            if( 1 )
+            {
+                bytes++;
+                int br = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                int hö = *(int *)bytes;
+                län -= 4;
+                kam->setSize( br, hö );
+            }
+            break;
+        case 4: // Zeit Beginn
+            spielPause = 0;
+            spielZeit = 0;
+            rZeit = 0;
+            rendern = 1;
+            break;
+        case 5: // spieler ist tod
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                Text *zName = 0;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    int team = spieler->z( i )->getTeam();
+                    int player = spieler->z( i )->getSpielerNummer();
+                    if( player == sNum )
+                    {
+                        spieler->z( i )->sterben( map->zMap(), zeit, spielZeit );
+                        bestenliste->updateSpielerStatus( spieler->z( i ) );
+                        zName = spieler->z( i )->zName();
+                        bool teamLebt = 0;
+                        for( int j = 0; j < spielerAnzahl; j++ )
+                        {
+                            if( spieler->z( j ) && spieler->z( j )->getTeam() == team )
+                                teamLebt |= spieler->z( j )->istAmLeben();
+                        }
+                        if( !teamLebt )
+                        {
+                            for( int j = 0; j < bestenliste->getTeamAnzahl(); j++ )
+                            {
+                                if( bestenliste->teamExistiert( j ) )
+                                {
+                                    bool amLeben = 0;
+                                    for( int k = 0; k < spielerAnzahl; k++ )
+                                    {
+                                        if( spieler->z( k ) && spieler->z( k )->getTeam() == j )
+                                            amLeben |= spieler->z( k )->istAmLeben();
+                                    }
+                                    if( amLeben )
+                                        bestenliste->addPunkt( j, 1 );
+                                    else
+                                        bestenliste->addPunkt( j, 0 );
+                                    if( bestenliste->getTeamPunkte( j ) <= 0 )
+                                        bestenliste->setTeamStatus( j, "tot", 0xFFFF0000 );
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if( spieler->z( i )->istAmLeben() )
+                            bestenliste->addPunkt( team, player, 1 );
+                    }
+                }
+                if( sNum == spielerNummer )
+                    chat->addNachricht( "Du bist gestorben.", 0xFFFFFF00 );
+                else if( zName )
+                {
+                    Text *txt = new Text( zName->getText() );
+                    txt->append( " ist gestorben." );
+                    chat->addNachricht( txt->getText(), 0xFFFFFF00 );
+                    txt->release();
+                }
+            }
+            break;
+        case 6: // spiel Ende
+            if( 1 )
+            {
+                bestenliste->updatePunkte();
+                bytes++;
+                char gewonnen = *bytes;
+                län--;
+                end = new Ende( schrift );
+                end->setGewonnen( gewonnen );
+            }
+            break;
+        case 7: // set Spieler Geschwindigkeit
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                double xSpeed = *(double *)bytes;
+                län -= 8;
+                bytes += 8;
+                double ySpeed = *(double *)bytes;
+                län -= 8;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == sNum )
+                        spieler->z( i )->setSpeed( xSpeed, ySpeed );
+                }
+            }
+            break;
+        case 8: // set Spieler Wendigkeit
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                double kurve = *(double *)bytes;
+                län -= 8;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == sNum )
+                        spieler->z( i )->setKurveSpeed( kurve );
+                }
+            }
+            break;
+        case 9: // set Spieler Kurve
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                char k = *bytes;
+                län--;
+                if( k == 0 )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == sNum )
+                        {
+                            spieler->z( i )->setLinksKurve( map->zMap(), 0, zeit, spielZeit );
+                            spieler->z( i )->setRechtsKurve( map->zMap(), 0, zeit, spielZeit );
+                        }
+                    }
+                }
+                else if( k == 1 )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == sNum )
+                            spieler->z( i )->setLinksKurve( map->zMap(), 1, zeit, spielZeit );
+                    }
+                }
+                else if( k == 2 )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == sNum )
+                            spieler->z( i )->setLinksKurve( map->zMap(), 0, zeit, spielZeit );
+                    }
+                }
+                else if( k == 3 )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == sNum )
+                            spieler->z( i )->setRechtsKurve( map->zMap(), 1, zeit, spielZeit );
+                    }
+                }
+                else if( k == 4 )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == sNum )
+                            spieler->z( i )->setRechtsKurve( map->zMap(), 0, zeit, spielZeit );
+                    }
+                }
+                else if( k == 5 )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == sNum )
+                        {
+                            spieler->z( i )->setLinksKurve( map->zMap(), 1, zeit, spielZeit );
+                            spieler->z( i )->setRechtsKurve( map->zMap(), 1, zeit, spielZeit );
+                        }
+                    }
+                }
+            }
+            break;
+        case 0xA: // set Karte Größe
+            if( 1 )
+            {
+                bytes++;
+                int br = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                int hö = *(int *)bytes;
+                län -= 4;
+                map->setSize( br, hö );
+            }
+            break;
+        case 0xB: // chat Nachricht
+            if( 1 )
+            {
+                bytes++;
+                Text *txt = new Text( "" );
+                txt->append( bytes, län );
+                chat->addNachricht( txt->getText() );
+                txt->release();
+                län = 0;
+            }
+            break;
+        case 0xC: // Spieler Linien Unterbrechung
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                char unterbrechung = *bytes;
+                län--;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    Spieler *tmp = spieler->z( i );
+                    if( tmp && tmp->getSpielerNummer() == sNum )
+                        tmp->setLinienUnterbrechung( map->zMap(), unterbrechung != 0, zeit, spielZeit );
+                }
+            }
+            break;
+        case 0xD: // Max Team Punkte 
+            if( 1 )
+            {
+                bytes++;
+                int team = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                int mP = *(int *)bytes;
+                län -= 4;
+                bestenliste->setTeamMaxPunkte( team, mP );
+            }
+            break;
+        case 0xE: // Team Punkte
+            if( 1 )
+            {
+                bytes++;
+                int team = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                int p = *(int *)bytes;
+                län -= 4;
+                bestenliste->setTeamPunkte( team, p );
+                if( !p )
+                    bestenliste->setTeamStatus( team, "tot", 0xFFFF0000 );
+            }
+            break;
+        case 0xF: // Spieler Punkte
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                int p = *(int *)bytes;
+                län -= 4;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i ) && spieler->z( i )->getSpielerNummer() == sNum )
+                    {
+                        bestenliste->setSpielerPunkte( spieler->z( i )->getTeam(), sNum, p );
+                        break;
+                    }
+                }
+            }
+            break;
+        case 0x10: // Team Tod
+            if( 1 )
+            {
+                bytes++;
+                int team = *(int *)bytes;
+                län -= 4;
+                bestenliste->setTeamPunkte( team, 0 );
+                bestenliste->setTeamStatus( team, "tot", 0xFFFF0000 );
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i ) && spieler->z( i )->getTeam() == team )
+                    {
+                        spieler->z( i )->sterben();
+                        bestenliste->updateSpielerStatus( spieler->z( i ) );
+                    }
+                }
+            }
+            break;
+        case 0x11: // Runden Ende
+            if( 1 )
+            {
+                spielPause = 1;
+                bytes++;
+                int team = *(int *)bytes;
+                län -= 4;
+                bool gewonnen = 0;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                    {
+                        gewonnen = spieler->z( i )->getTeam() == team;
+                        break;
+                    }
+                }
+                rEnd->setGewonnen( gewonnen );
+                bestenliste->updatePunkte();
+                rEnd->setSichtbar( 1 );
+            }
+            break;
+        case 0x12: // Verbleibende Zeit
+            if( 1 )
+            {
+                bytes++;
+                int sek = *(int *)bytes;
+                län -= 4;
+                rEnd->setZeit( sek );
+                if( !sek )
+                {
+                    if( rEnd && rEnd->istSichtbar() )
+                    {
+                        rEnd->setSichtbar( 0 );
+                        rEnd->setZeit( 6 );
+                        for( int i = 0; i < spielerAnzahl; i++ )
+                        {
+                            if( spieler->z( i ) )
+                            {
+                                spieler->z( i )->neuRunde();
+                                if( !bestenliste->getTeamPunkte( spieler->z( i )->getTeam() ) )
+                                    spieler->z( i )->sterben();
+                                bestenliste->updateSpielerStatus( spieler->z( i ) );
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+        case 0x13: // Team Name
+            if( 1 )
+            {
+                bytes++;
+                int team = *(int *)bytes;
+                län -= 4;
+                bytes += 4;
+                char *n = new char[ län + 1 ];
+                n[ län ] = 0;
+                memcpy( n, bytes, län );
+                län -= län;
+                bestenliste->setTeamName( team, n );
+                delete[] n;
+            }
+            break;
+        default:
+            // Fehler beim verarbeiten
+            break;
+        }
+        if( län != 0 )
+        {
+            // Fehler beim verarbeiten
+            chat->addNachricht( "Es ist ein Fehler beim verarbeiten einer Nachricht aufgetreten.", 0xFFFF0000 );
+        }
+        n->setVerarbeitet();
+    }
+    for( int i = stkna; i > 0; i-- )
+    {
+        if( !stkn->z( 0 ) || !stkn->z( 0 )->istVerarbeitet() )
+            break;
+        stkna--;
+        stkn->remove( 0 );
+    }
+    unlock();
 }
 
 bool SpielKlasse::tick( double zeit )
 {
-	if( spielPause )
-	{
-		zeit = 0;
-		stknVerarbeitung();
-	}
-	rZeit += zeit;
-	while( spielZeit + TICK < rZeit )
-	{
-		spielZeit += TICK;
-		stknVerarbeitung();
-		if( end )
-			return 1;
-		if( !rEnd->istSichtbar() )
-		{
-			int x = 0;
-			int y = 0;
-			bool setKam = 0;
-			lock();
-			for( int i = 0; i < spielerAnzahl; i++ )
-			{
-				spieler->z( i )->tick( map->zMap(), TICK );
-				if( spielerNummer == spieler->z( i )->getSpielerNummer() )
-				{
-					x = (int)spieler->z( i )->getX();
-					y = (int)spieler->z( i )->getY();
-					setKam = spieler->z( i )->istAmLeben();
-				}
-			}
-			unlock();
-			if( setKam )
-			{
-				double px = ( ( x - kam->getX() ) / 100.0 ) * ( 50 * TICK );
-				double py = ( ( y - kam->getY() ) / 100.0 ) * ( 50 * TICK );
-				kam->addPosition( (int)px, (int)py, map );
-			}
-		}
-		chat->tick( !zeit ? 0.05 : zeit );
-	}
-	return 1;
+    if( spielPause )
+    {
+        zeit = 0;
+        stknVerarbeitung();
+    }
+    rZeit += zeit;
+    while( spielZeit + TICK < rZeit )
+    {
+        spielZeit += TICK;
+        stknVerarbeitung();
+        if( end )
+            return 1;
+        if( !rEnd->istSichtbar() )
+        {
+            int x = 0;
+            int y = 0;
+            bool setKam = 0;
+            lock();
+            for( int i = 0; i < spielerAnzahl; i++ )
+            {
+                spieler->z( i )->tick( map->zMap(), TICK );
+                if( spielerNummer == spieler->z( i )->getSpielerNummer() )
+                {
+                    x = (int)spieler->z( i )->getX();
+                    y = (int)spieler->z( i )->getY();
+                    setKam = spieler->z( i )->istAmLeben();
+                }
+            }
+            unlock();
+            if( setKam )
+            {
+                double px = ( ( x - kam->getX() ) / 100.0 ) * ( 50 * TICK );
+                double py = ( ( y - kam->getY() ) / 100.0 ) * ( 50 * TICK );
+                kam->addPosition( (int)px, (int)py, map );
+            }
+        }
+        chat->tick( !zeit ? 0.05 : zeit );
+    }
+    return 1;
 }
 
 void SpielKlasse::render( Bild &zRObj )
 {
-	if( !rendern )
-		return;
-	lock();
-	chat->render( zRObj );
-	if( bestenliste )
-		bestenliste->render( zRObj );
-	kam->render( zRObj );
-	int x = kam->getRX( kam->getLinks() ) + 1, y = kam->getRY( kam->getOben() ) + 1;
-	if( zRObj.setDrawOptions( x, y, kam->getRechts() - kam->getLinks() - 2, kam->getUnten() - kam->getOben() - 2 ) )
-	{
-		zRObj.addScrollOffset( x, y );
-		map->render( kam, zRObj );
-		for( int i = 0; i < spielerAnzahl; i++ )
-			spieler->z( i )->render( kam, zRObj );
-		zRObj.releaseDrawOptions();
-	}
-	if( rEnd )
-		rEnd->render( zRObj );
-	if( end )
-		end->render( zRObj );
-	unlock();
+    if( !rendern )
+        return;
+    lock();
+    chat->render( zRObj );
+    if( bestenliste )
+        bestenliste->render( zRObj );
+    kam->render( zRObj );
+    int x = kam->getRX( kam->getLinks() ) + 1, y = kam->getRY( kam->getOben() ) + 1;
+    if( zRObj.setDrawOptions( x, y, kam->getRechts() - kam->getLinks() - 2, kam->getUnten() - kam->getOben() - 2 ) )
+    {
+        zRObj.addScrollOffset( x, y );
+        map->render( kam, zRObj );
+        for( int i = 0; i < spielerAnzahl; i++ )
+            spieler->z( i )->render( kam, zRObj );
+        zRObj.releaseDrawOptions();
+    }
+    if( rEnd )
+        rEnd->render( zRObj );
+    if( end )
+        end->render( zRObj );
+    unlock();
 }
 
 // constant
 int SpielKlasse::läuft() const
 {
-	if( !rendern )
-		return 3;
-	if( !end )
-		return 2;
-	if( end && !end->getWeiter() )
-		return 1;
-	if( end && end->getWeiter() )
-		return 0;
-	return 0;
+    if( !rendern )
+        return 3;
+    if( !end )
+        return 2;
+    if( end && !end->getWeiter() )
+        return 1;
+    if( end && end->getWeiter() )
+        return 0;
+    return 0;
 }
 
 // Reference Counting
 SpielV *SpielKlasse::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 SpielV *SpielKlasse::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/Spiel/Spieler/Spieler.cpp

@@ -7,374 +7,374 @@
 // Konstruktor
 Spieler::Spieler( KSGClient::InformationServerClient *zInfoK )
 {
-	xPos = 0;
-	yPos = 0;
-	xSpeed = 0;
-	ySpeed = 0;
-	kurve = 0;
-	lKurve = 0;
-	rKurve = 0;
-	spielerNummer = 0;
-	team = 0;
-	radius = 1;
-	teamRahmen = new LRahmen();
-	teamRahmen->setRamenBreite( 1 );
-	spielerFarbe = 0;
-	teamFarbe = 0;
-	info = zInfoK->getThis();
-	name = 0;
-	accId = 0;
-	amLeben = 1;
-	linieUnterbrochen = 1;
-	ref = 1;
+    xPos = 0;
+    yPos = 0;
+    xSpeed = 0;
+    ySpeed = 0;
+    kurve = 0;
+    lKurve = 0;
+    rKurve = 0;
+    spielerNummer = 0;
+    team = 0;
+    radius = 1;
+    teamRahmen = new LRahmen();
+    teamRahmen->setRamenBreite( 1 );
+    spielerFarbe = 0;
+    teamFarbe = 0;
+    info = zInfoK->getThis();
+    name = 0;
+    accId = 0;
+    amLeben = 1;
+    linieUnterbrochen = 1;
+    ref = 1;
 }
 
 // Destruktor
 Spieler::~Spieler()
 {
-	teamRahmen->release();
-	info->release();
-	if( name )
-		name->release();
+    teamRahmen->release();
+    info->release();
+    if( name )
+        name->release();
 }
 
 // nicht constant
 void Spieler::neuRunde()
 {
-	xPos = 0;
-	yPos = 0;
-	xSpeed = 0;
-	ySpeed = 0;
-	kurve = 0;
-	lKurve = 0;
-	rKurve = 0;
-	radius = 1;
-	amLeben = 1;
-	linieUnterbrochen = 1;
+    xPos = 0;
+    yPos = 0;
+    xSpeed = 0;
+    ySpeed = 0;
+    kurve = 0;
+    lKurve = 0;
+    rKurve = 0;
+    radius = 1;
+    amLeben = 1;
+    linieUnterbrochen = 1;
 }
 
 void Spieler::setAccountId( int accId )
 {
-	this->accId = accId;
-	name = info->getSpielerName( accId );
+    this->accId = accId;
+    name = info->getSpielerName( accId );
 }
 
 void Spieler::setSpielerNummer( int num )
 {
-	spielerNummer = num;
+    spielerNummer = num;
 }
 
 void Spieler::setTeam( int team )
 {
-	this->team = team;
+    this->team = team;
 }
 
 void Spieler::setTeamFarbe( int fc )
 {
-	teamFarbe = fc;
+    teamFarbe = fc;
 }
 
 void Spieler::setSpielerFarbe( int fc )
 {
-	spielerFarbe = fc;
+    spielerFarbe = fc;
 }
 
 void Spieler::setPos( double x, double y )
 {
-	xPos = x;
-	yPos = y;
+    xPos = x;
+    yPos = y;
 }
 
 void Spieler::setRadius( int r )
 {
-	radius = r;
+    radius = r;
 }
 
 void Spieler::setSpeed( double xSpeed, double ySpeed )
 {
-	this->xSpeed = xSpeed;
-	this->ySpeed = ySpeed;
+    this->xSpeed = xSpeed;
+    this->ySpeed = ySpeed;
 }
 
 void Spieler::setKurveSpeed( double kurve )
 {
-	this->kurve = kurve;
+    this->kurve = kurve;
 }
 
 void Spieler::setLinksKurve( Bild *zMap, bool lKurve, double sendeZeit, double spielZeit )
 {
-	double sZ = -1;
-	if( sendeZeit < spielZeit )
-	{
-		sZ = spielZeit;
-		while( sendeZeit < spielZeit )
-		{
-			tick( zMap, -TICK );
-			spielZeit -= TICK;
-		}
-	}
-	this->lKurve = lKurve;
-	if( sZ >= 0 )
-	{
-		while( spielZeit < sZ )
-		{
-			tick( zMap, TICK );
-			spielZeit += TICK;
-		}
-	}
+    double sZ = -1;
+    if( sendeZeit < spielZeit )
+    {
+        sZ = spielZeit;
+        while( sendeZeit < spielZeit )
+        {
+            tick( zMap, -TICK );
+            spielZeit -= TICK;
+        }
+    }
+    this->lKurve = lKurve;
+    if( sZ >= 0 )
+    {
+        while( spielZeit < sZ )
+        {
+            tick( zMap, TICK );
+            spielZeit += TICK;
+        }
+    }
 }
 
 void Spieler::setRechtsKurve( Bild *zMap, bool rKurve, double sendeZeit, double spielZeit )
 {
-	double sZ = -1;
-	if( sendeZeit < spielZeit )
-	{
-		sZ = spielZeit;
-		while( sendeZeit < spielZeit )
-		{
-			tick( zMap, -TICK );
-			spielZeit -= TICK;
-		}
-	}
-	this->rKurve = rKurve;
-	if( sZ >= 0 )
-	{
-		while( spielZeit < sZ )
-		{
-			tick( zMap, TICK );
-			spielZeit += TICK;
-		}
-	}
+    double sZ = -1;
+    if( sendeZeit < spielZeit )
+    {
+        sZ = spielZeit;
+        while( sendeZeit < spielZeit )
+        {
+            tick( zMap, -TICK );
+            spielZeit -= TICK;
+        }
+    }
+    this->rKurve = rKurve;
+    if( sZ >= 0 )
+    {
+        while( spielZeit < sZ )
+        {
+            tick( zMap, TICK );
+            spielZeit += TICK;
+        }
+    }
 }
 
 void Spieler::sterben( Bild *zMap, double sendeZeit, double spielZeit )
 {
-	if( sendeZeit < spielZeit )
-	{
-		while( sendeZeit < spielZeit )
-		{
-			tick( zMap, -TICK );
-			spielZeit -= TICK;
-		}
-	}
-	amLeben = 0;
+    if( sendeZeit < spielZeit )
+    {
+        while( sendeZeit < spielZeit )
+        {
+            tick( zMap, -TICK );
+            spielZeit -= TICK;
+        }
+    }
+    amLeben = 0;
 }
 
 void Spieler::sterben()
 {
-	amLeben = 0;
+    amLeben = 0;
 }
 
 void Spieler::setLinienUnterbrechung( Bild *zMap, bool unterbrechung, double sendeZeit, double spielZeit )
 {
-	double sZ = -1;
-	if( sendeZeit < spielZeit )
-	{
-		sZ = spielZeit;
-		while( sendeZeit < spielZeit )
-		{
-			tick( zMap, -TICK );
-			spielZeit -= TICK;
-		}
-	}
-	linieUnterbrochen = unterbrechung;
-	if( sZ >= 0 )
-	{
-		while( spielZeit < sZ )
-		{
-			tick( zMap, TICK );
-			spielZeit += TICK;
-		}
-	}
+    double sZ = -1;
+    if( sendeZeit < spielZeit )
+    {
+        sZ = spielZeit;
+        while( sendeZeit < spielZeit )
+        {
+            tick( zMap, -TICK );
+            spielZeit -= TICK;
+        }
+    }
+    linieUnterbrochen = unterbrechung;
+    if( sZ >= 0 )
+    {
+        while( spielZeit < sZ )
+        {
+            tick( zMap, TICK );
+            spielZeit += TICK;
+        }
+    }
 }
 
 void Spieler::prozessKurve( double zeit )
 {
-	if( lKurve || rKurve )
-	{
-		double grad = kurve * zeit;
-		if( lKurve )
-			grad = -grad;
-		double cs = cos( grad );
-		double sn = sin( grad );
-		double tmpX = ( xSpeed * cs - ySpeed * sn );
-		double tmpY = ( xSpeed * sn + ySpeed * cs );
-		xSpeed = tmpX;
-		ySpeed = tmpY;
-	}
+    if( lKurve || rKurve )
+    {
+        double grad = kurve * zeit;
+        if( lKurve )
+            grad = -grad;
+        double cs = cos( grad );
+        double sn = sin( grad );
+        double tmpX = ( xSpeed * cs - ySpeed * sn );
+        double tmpY = ( xSpeed * sn + ySpeed * cs );
+        xSpeed = tmpX;
+        ySpeed = tmpY;
+    }
 }
 
 void Spieler::tick( Bild *zMap, double zeit )
 {
-	if( amLeben )
-	{
-		if( zeit > 0 )
-			prozessKurve( zeit );
-		int dpx = 0;
-		int dpy = 0;
-		int dgx = zMap->getBreite();
-		int dgy = zMap->getHeight();
-		int *buff = zMap->getBuffer();
-		if( zMap && !linieUnterbrochen )
-		{
-			int x1 = (int)( xPos + 0.5 );
-			int y1 = (int)( yPos + 0.5 );
-			int x2 = (int)( xPos + xSpeed * zeit + 0.5 );
-			int y2 = (int)( yPos + ySpeed * zeit + 0.5 );
-			int xlän = x2 - x1, axlän = abs( xlän );
-			int ylän = y2 - y1, aylän = abs( ylän );
-			double xf = (double)xlän / ( aylän ? aylän : 1 );
-			double yf = (double)ylän / ( axlän ? axlän : 1 );
-			if( axlän > aylän )
-				xf = xf < 0 ? -1 : 1;
-			else
-				yf = yf < 0 ? -1 : 1;
-			double x = (double)x1, y = (double)y1;
-			int maxP = (int)( sqrt( (double)( xlän * xlän + ylän * ylän ) ) + 0.5 );
-			int count = 0;
-			int lastX = (int)( x + 0.5 ), lastY = (int)( y + 0.5 );
-			if( zeit > 0 )
-			{
-				while( !( (int)( x + 0.5 ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
-				{
-					if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
-					{
-						x += xf, y += yf;
-						lastX = (int)( x + 0.5 );
-						lastY = (int)( y + 0.5 );
-						count++;
-						continue;
-					}
-					buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
-					x += xf, y += yf;
-					if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
-					{
-						if( (int)xf )
-						{
-							if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
-								buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
-						}
-						else
-						{
-							if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
-								buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = spielerFarbe;
-						}
-					}
-					lastX = (int)( x + 0.5 );
-					lastY = (int)( y + 0.5 );
-					count++;
-				}
-			}
-			if( zeit < 0 )
-			{
-				while( !( (int)( x ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
-				{
-					count++;
-					x += xf, y += yf;
-					if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
-					{
-						if( (int)xf )
-						{
-							if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
-								buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = 0;
-						}
-						else
-						{
-							if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
-								buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
-						}
-					}
-					lastX = (int)( x + 0.5 );
-					lastY = (int)( y + 0.5 );
-					if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
-						buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
-				}
-			}
-		}
-		xPos += xSpeed * zeit;
-		yPos += ySpeed * zeit;
-		if( zeit < 0 )
-			prozessKurve( zeit );
-	}
+    if( amLeben )
+    {
+        if( zeit > 0 )
+            prozessKurve( zeit );
+        int dpx = 0;
+        int dpy = 0;
+        int dgx = zMap->getBreite();
+        int dgy = zMap->getHeight();
+        int *buff = zMap->getBuffer();
+        if( zMap && !linieUnterbrochen )
+        {
+            int x1 = (int)( xPos + 0.5 );
+            int y1 = (int)( yPos + 0.5 );
+            int x2 = (int)( xPos + xSpeed * zeit + 0.5 );
+            int y2 = (int)( yPos + ySpeed * zeit + 0.5 );
+            int xlän = x2 - x1, axlän = abs( xlän );
+            int ylän = y2 - y1, aylän = abs( ylän );
+            double xf = (double)xlän / ( aylän ? aylän : 1 );
+            double yf = (double)ylän / ( axlän ? axlän : 1 );
+            if( axlän > aylän )
+                xf = xf < 0 ? -1 : 1;
+            else
+                yf = yf < 0 ? -1 : 1;
+            double x = (double)x1, y = (double)y1;
+            int maxP = (int)( sqrt( (double)( xlän * xlän + ylän * ylän ) ) + 0.5 );
+            int count = 0;
+            int lastX = (int)( x + 0.5 ), lastY = (int)( y + 0.5 );
+            if( zeit > 0 )
+            {
+                while( !( (int)( x + 0.5 ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
+                {
+                    if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
+                    {
+                        x += xf, y += yf;
+                        lastX = (int)( x + 0.5 );
+                        lastY = (int)( y + 0.5 );
+                        count++;
+                        continue;
+                    }
+                    buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
+                    x += xf, y += yf;
+                    if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
+                    {
+                        if( (int)xf )
+                        {
+                            if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
+                                buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
+                        }
+                        else
+                        {
+                            if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
+                                buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = spielerFarbe;
+                        }
+                    }
+                    lastX = (int)( x + 0.5 );
+                    lastY = (int)( y + 0.5 );
+                    count++;
+                }
+            }
+            if( zeit < 0 )
+            {
+                while( !( (int)( x ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
+                {
+                    count++;
+                    x += xf, y += yf;
+                    if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
+                    {
+                        if( (int)xf )
+                        {
+                            if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
+                                buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = 0;
+                        }
+                        else
+                        {
+                            if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
+                                buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
+                        }
+                    }
+                    lastX = (int)( x + 0.5 );
+                    lastY = (int)( y + 0.5 );
+                    if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
+                        buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
+                }
+            }
+        }
+        xPos += xSpeed * zeit;
+        yPos += ySpeed * zeit;
+        if( zeit < 0 )
+            prozessKurve( zeit );
+    }
 }
 
 void Spieler::render( Kamera *zKam, Bild &zRObj )
 {
-	if( amLeben )
-	{
-		if( zKam->istSichtbar( (int)xPos, (int)yPos ) )
-		{
-			teamRahmen->setFarbe( teamFarbe );
-			teamRahmen->setSize( 5 * 2, 5 * 2 );
-			teamRahmen->setPosition( zKam->getRX( (int)xPos ) - 5, zKam->getRY( (int)yPos ) - 5 );
-			zRObj.fillRegion( teamRahmen->getX(), teamRahmen->getY(), 5 * 2, 5 * 2, spielerFarbe );
-			teamRahmen->render( zRObj );
-		}
-	}
+    if( amLeben )
+    {
+        if( zKam->istSichtbar( (int)xPos, (int)yPos ) )
+        {
+            teamRahmen->setFarbe( teamFarbe );
+            teamRahmen->setSize( 5 * 2, 5 * 2 );
+            teamRahmen->setPosition( zKam->getRX( (int)xPos ) - 5, zKam->getRY( (int)yPos ) - 5 );
+            zRObj.fillRegion( teamRahmen->getX(), teamRahmen->getY(), 5 * 2, 5 * 2, spielerFarbe );
+            teamRahmen->render( zRObj );
+        }
+    }
 }
 
 // constant
 double Spieler::getX() const
 {
-	return xPos;
+    return xPos;
 }
 
 double Spieler::getY() const
 {
-	return yPos;
+    return yPos;
 }
 
 int Spieler::getTeam() const
 {
-	return team;
+    return team;
 }
 
 int Spieler::getTeamFarbe() const
 {
-	return teamFarbe;
+    return teamFarbe;
 }
 
 int Spieler::getFarbe() const
 {
-	return spielerFarbe;
+    return spielerFarbe;
 }
 
 int Spieler::getSpielerNummer() const
 {
-	return spielerNummer;
+    return spielerNummer;
 }
 
 bool Spieler::istAmLeben() const
 {
-	return amLeben;
+    return amLeben;
 }
 
 int Spieler::getAccountId() const
 {
-	return accId;
+    return accId;
 }
 
 Text *Spieler::getName() const
 {
-	return name ? name->getThis() : 0;
+    return name ? dynamic_cast<Text *>( name->getThis() ) : 0;
 }
 
 Text *Spieler::zName() const
 {
-	return name;
+    return name;
 }
 
 // Reference Counting
 Spieler *Spieler::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Spieler *Spieler::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/SpielStatistik/SpielStatistik.cpp

@@ -7,554 +7,554 @@
 // Konstruktor
 SpielStatistik::SpielStatistik()
 {
-	InitializeCriticalSection( &cs );
-	addNachrichtF = 0;
-	addChatF = 0;
-	addFreundF = 0;
-	accountAnsehenF = 0;
-	istFreundF = 0;
-	nachrichtParam = 0;
-	bilder = 0;
-	schrift = 0;
-	screen = 0;
-	infoc = 0;
-	spielc = 0;
-	status = 0;
-	gss = new Array< SSDGesamtSpieler* >();
-	gts = new Array< SSDGesamtTeam* >();
-	rs = new Array< SSDRunde* >();
-	chat = 0;
-	runde = 0;
-	tabelle = 0;
-	accountId = 0;
-	rend = 0;
-	ref = 1;
+    InitializeCriticalSection( &cs );
+    addNachrichtF = 0;
+    addChatF = 0;
+    addFreundF = 0;
+    accountAnsehenF = 0;
+    istFreundF = 0;
+    nachrichtParam = 0;
+    bilder = 0;
+    schrift = 0;
+    screen = 0;
+    infoc = 0;
+    spielc = 0;
+    status = 0;
+    gss = new Array< SSDGesamtSpieler * >();
+    gts = new Array< SSDGesamtTeam * >();
+    rs = new Array< SSDRunde * >();
+    chat = 0;
+    runde = 0;
+    tabelle = 0;
+    accountId = 0;
+    rend = 0;
+    ref = 1;
 }
 
 // Destruktor
 SpielStatistik::~SpielStatistik()
 {
-	if( chat )
-		chat->release();
-	if( runde )
-		runde->release();
-	if( tabelle )
-		tabelle->release();
-	if( schrift )
-		schrift->release();
-	if( infoc )
-		infoc->release();
-	if( spielc )
-		spielc->release();
-	int anz = gss->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( gss->hat( i ) )
-			delete gss->get( i );
-	}
-	gss->release();
-	anz = gts->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( gts->hat( i ) )
-			delete gts->get( i );
-	}
-	gts->release();
-	anz = rs->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( rs->hat( i ) )
-		{
-			int anz2 = rs->get( i )->spieler.getEintragAnzahl();
-			for( int j = 0; j < anz2; j++ )
-			{
-				if( rs->get( i )->spieler.hat( j ) )
-					delete rs->get( i )->spieler.get( j );
-			}
-			anz2 = rs->get( i )->teams.getEintragAnzahl();
-			for( int j = 0; j < anz2; j++ )
-			{
-				if( rs->get( i )->teams.hat( j ) )
-					delete rs->get( i )->teams.get( j );
-			}
-			delete rs->get( i );
-		}
-	}
-	rs->release();
-	DeleteCriticalSection( &cs );
+    if( chat )
+        chat->release();
+    if( runde )
+        runde->release();
+    if( tabelle )
+        tabelle->release();
+    if( schrift )
+        schrift->release();
+    if( infoc )
+        infoc->release();
+    if( spielc )
+        spielc->release();
+    int anz = gss->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( gss->hat( i ) )
+            delete gss->get( i );
+    }
+    gss->release();
+    anz = gts->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( gts->hat( i ) )
+            delete gts->get( i );
+    }
+    gts->release();
+    anz = rs->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( rs->hat( i ) )
+        {
+            int anz2 = rs->get( i )->spieler.getEintragAnzahl();
+            for( int j = 0; j < anz2; j++ )
+            {
+                if( rs->get( i )->spieler.hat( j ) )
+                    delete rs->get( i )->spieler.get( j );
+            }
+            anz2 = rs->get( i )->teams.getEintragAnzahl();
+            for( int j = 0; j < anz2; j++ )
+            {
+                if( rs->get( i )->teams.hat( j ) )
+                    delete rs->get( i )->teams.get( j );
+            }
+            delete rs->get( i );
+        }
+    }
+    rs->release();
+    DeleteCriticalSection( &cs );
 }
 
 // nicht constant
 void SpielStatistik::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void SpielStatistik::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 void SpielStatistik::bereit()
 {
-	char byte = 1;
-	spielc->statistikNachricht( 1, &byte );
+    char byte = 1;
+    spielc->statistikNachricht( 1, &byte );
 }
 
 void SpielStatistik::setBilder( BilderV *b )
 {
-	bilder = b;
+    bilder = b;
 }
 
 void SpielStatistik::setAccountId( int id )
 {
-	accountId = id;
+    accountId = id;
 }
 
 void SpielStatistik::setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * ),
-										   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
-										   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam )
+                                           void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+                                           void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam )
 {
-	this->addNachrichtF = addNachrichtF;
-	this->addChatF = addChatF;
-	this->addFreundF = addFreundF;
-	this->accountAnsehenF = accountAnsehenF;
-	this->istFreundF = istFreundF;
-	this->nachrichtParam = nachrichtParam;
+    this->addNachrichtF = addNachrichtF;
+    this->addChatF = addChatF;
+    this->addFreundF = addFreundF;
+    this->accountAnsehenF = accountAnsehenF;
+    this->istFreundF = istFreundF;
+    this->nachrichtParam = nachrichtParam;
 }
 
 void SpielStatistik::setSchrift( Schrift *schrift )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
 }
 
 void SpielStatistik::setBildschirm( Bildschirm *zScreen )
 {
-	screen = zScreen;
+    screen = zScreen;
 }
 
 void SpielStatistik::setKlients( KSGClient::InformationServerClient *infoc, KSGClient::SpielServerClient *spielc )
 {
-	if( this->infoc )
-		this->infoc->release();
-	if( this->spielc )
-		this->spielc->release();
-	this->infoc = infoc;
-	this->spielc = spielc;
+    if( this->infoc )
+        this->infoc->release();
+    if( this->spielc )
+        this->spielc->release();
+    this->infoc = infoc;
+    this->spielc = spielc;
 }
 
 void SpielStatistik::nachricht( int län, char *bytes )
 {
-	lock();
-	char num = *bytes;
-	bytes++;
-	län--;
-	switch( num )
-	{
-	case 1: // Ladevorgang abgeschlossen
-		if( 1 )
-		{
-			chat = new StatistikChat( accountId, spielc->getThis(), infoc->getThis(), schrift->getThis(), bilder, addNachrichtF, addChatF, addFreundF, accountAnsehenF, nachrichtParam );
-			int anz = gss->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-			{
-				if( gss->hat( i ) )
-				{
-					int acc = infoc->getAccountId( gss->get( i )->spielerName );
-					if( acc )
-						chat->addSpieler( acc, istFreundF( nachrichtParam, acc ) || acc == accountId );
-				}
-			}
-			runde = new StatistikRunde( schrift, rs->getThis() );
-			tabelle = new StatistikTabelle( gss->getThis(), gts->getThis(), rs->getThis(), schrift, screen );
-			status = 1;
-		}
-		break;
-	case 2: // Gesammt Spieler Statistik
-		if( 1 )
-		{
-			SSDGesamtSpieler *ssdgs = new SSDGesamtSpieler();
-			ssdgs->spielerNummer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			char snlän = *bytes;
-			län--;
-			bytes++;
-			char *txt = new char[ snlän + 1 ];
-			txt[ snlän ] = 0;
-			for( int i = 0; i < snlän; i++ )
-				txt[ i ] = bytes[ i ];
-			bytes += snlän;
-			län -= snlän;
-			ssdgs->spielerName = txt;
-			delete[] txt;
-			char tnlän = *bytes;
-			län--;
-			bytes++;
-			txt = new char[ tnlän + 1 ];
-			txt[ tnlän ] = 0;
-			for( int i = 0; i < tnlän; i++ )
-				txt[ i ] = bytes[ i ];
-			bytes += tnlän;
-			län -= tnlän;
-			ssdgs->teamName = txt;
-			delete[] txt;
-			ssdgs->spielerFarbe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->teamFarbe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->gewonneneRunden = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->punkte = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->linienLänge = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->zeitAmLeben = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->zeitTod = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->kills = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->tode = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			gss->add( ssdgs );
-		}
-		break;
-	case 3: // Gesammt Team Statistik
-		if( 1 )
-		{
-			SSDGesamtTeam *ssdgt = new SSDGesamtTeam();
-			ssdgt->teamNummer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			char tnlän = *bytes;
-			län--;
-			bytes++;
-			char *txt = new char[ tnlän + 1 ];
-			txt[ tnlän ] = 0;
-			for( int i = 0; i < tnlän; i++ )
-				txt[ i ] = bytes[ i ];
-			bytes += tnlän;
-			län -= tnlän;
-			ssdgt->teamName = txt;
-			delete[] txt;
-			ssdgt->teamFarbe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->gewonneneRunden = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->punkte = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->linienLänge = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->kills = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->tode = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			gts->add( ssdgt );
-		}
-		break;
-	case 4: // Runde Statistik
-		if( 1 )
-		{
-			SSDRunde *ssdr = new SSDRunde();
-			ssdr->rundenNummer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdr->rundenDauer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdr->rundenSieger = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdr->spielfeldNutzung = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			int breite = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			int höhe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdr->rundenBild.neuBild( breite, höhe, 0 );
-			rs->add( ssdr );
-		}
-		break;
-	case 5: // Runde Bild
-		if( 1 )
-		{
-			int runde = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			int *buff = 0;
-			int max = 0;
-			int anz = rs->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-			{
-				if( rs->hat( i ) && rs->get( i )->rundenNummer == runde )
-				{
-					buff = rs->get( i )->rundenBild.getBuffer();
-					max = rs->get( i )->rundenBild.getBreite() * rs->get( i )->rundenBild.getHeight();
-					break;
-				}
-			}
-			if( !buff )
-				break;
-			int index = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			int plän = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			for( int i = 0; i < plän; i++ )
-			{
-				if( index + i >= max )
-					break;
-				buff[ index + i ] = *(int*)bytes;
-				bytes += 4;
-				län -= 4;
-			}
-		}
-		break;
-	case 6: // Runde Spieler Statistik
-		if( 1 )
-		{
-			int runde = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			int anz = rs->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-			{
-				if( rs->hat( i ) && rs->get( i )->rundenNummer == runde )
-				{
-					SSDRundeSpieler *ssdrs = new SSDRundeSpieler();
-					ssdrs->spielerNummer = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					char snlän = *bytes;
-					län--;
-					bytes++;
-					char *txt = new char[ snlän + 1 ];
-					txt[ snlän ] = 0;
-					for( int j = 0; j < snlän; j++ )
-						txt[ j ] = bytes[ j ];
-					bytes += snlän;
-					län -= snlän;
-					ssdrs->spielerName = txt;
-					delete[] txt;
-					char tnlän = *bytes;
-					län--;
-					bytes++;
-					txt = new char[ tnlän + 1 ];
-					txt[ tnlän ] = 0;
-					for( int j = 0; j < tnlän; j++ )
-						txt[ j ] = bytes[ j ];
-					bytes += tnlän;
-					län -= tnlän;
-					ssdrs->teamName = txt;
-					delete[] txt;
-					ssdrs->spielerFarbe = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrs->teamFarbe = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrs->linienLänge = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrs->kills = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrs->todesZeit = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					rs->get( i )->spieler.add( ssdrs );
-					break;
-				}
-			}
-		}
-		break;
-	case 7: // Runde Team Statistik
-		if( 1 )
-		{
-			int runde = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			int anz = rs->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-			{
-				if( rs->hat( i ) && rs->get( i )->rundenNummer == runde )
-				{
-					SSDRundeTeam *ssdrt = new SSDRundeTeam();
-					ssdrt->teamNummer = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					char tnlän = *bytes;
-					län--;
-					bytes++;
-					char *txt = new char[ tnlän + 1 ];
-					txt[ tnlän ] = 0;
-					for( int j = 0; j < tnlän; j++ )
-						txt[ j ] = bytes[ j ];
-					bytes += tnlän;
-					län -= tnlän;
-					ssdrt->teamName = txt;
-					delete[] txt;
-					ssdrt->teamFarbe = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrt->ergebnis = *bytes;
-					bytes++;
-					län--;
-					ssdrt->linienLänge = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrt->kills = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					ssdrt->tode = *(int*)bytes;
-					bytes += 4;
-					län -= 4;
-					rs->get( i )->teams.add( ssdrt );
-					break;
-				}
-			}
-		}
-		break;
-	case 8: // Chat Nachricht
-		if( 1 )
-		{
-			int vonAccount = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			char *txt = new char[ län + 1 ];
-			txt[ län ] = 0;
-			for( int i = 0; i < län; i++ )
-				txt[ i ] = bytes[ i ];
-			if( status == 1 )
-				chat->addChatNachricht( vonAccount, txt );
-			delete[] txt;
-		}
-		break;
-	case 9: // Spieler hat verlassen
-		if( 1 )
-		{
-			int acc = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			if( status == 1 )
-				chat->spielerOffline( acc );
-		}
-		break;
-	default:
-		// Fehler
-		break;
-	}
-	if( län != 0 )
-	{
-		// Fehler
-	}
-	unlock();
+    lock();
+    char num = *bytes;
+    bytes++;
+    län--;
+    switch( num )
+    {
+    case 1: // Ladevorgang abgeschlossen
+        if( 1 )
+        {
+            chat = new StatistikChat( accountId, dynamic_cast<KSGClient::SpielServerClient *>( spielc->getThis() ), dynamic_cast<KSGClient::InformationServerClient *>( infoc->getThis() ), dynamic_cast<Schrift *>( schrift->getThis() ), bilder, addNachrichtF, addChatF, addFreundF, accountAnsehenF, nachrichtParam );
+            int anz = gss->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                if( gss->hat( i ) )
+                {
+                    int acc = infoc->getAccountId( gss->get( i )->spielerName );
+                    if( acc )
+                        chat->addSpieler( acc, istFreundF( nachrichtParam, acc ) || acc == accountId );
+                }
+            }
+            runde = new StatistikRunde( schrift, dynamic_cast<Array<SSDRunde *> *>( rs->getThis() ) );
+            tabelle = new StatistikTabelle( dynamic_cast<Array<SSDGesamtSpieler *> *>( gss->getThis() ), dynamic_cast<Array<SSDGesamtTeam *> *>( gts->getThis() ), dynamic_cast<Array<SSDRunde *> *>( rs->getThis() ), schrift, screen );
+            status = 1;
+        }
+        break;
+    case 2: // Gesammt Spieler Statistik
+        if( 1 )
+        {
+            SSDGesamtSpieler *ssdgs = new SSDGesamtSpieler();
+            ssdgs->spielerNummer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            char snlän = *bytes;
+            län--;
+            bytes++;
+            char *txt = new char[ snlän + 1 ];
+            txt[ snlän ] = 0;
+            for( int i = 0; i < snlän; i++ )
+                txt[ i ] = bytes[ i ];
+            bytes += snlän;
+            län -= snlän;
+            ssdgs->spielerName = txt;
+            delete[] txt;
+            char tnlän = *bytes;
+            län--;
+            bytes++;
+            txt = new char[ tnlän + 1 ];
+            txt[ tnlän ] = 0;
+            for( int i = 0; i < tnlän; i++ )
+                txt[ i ] = bytes[ i ];
+            bytes += tnlän;
+            län -= tnlän;
+            ssdgs->teamName = txt;
+            delete[] txt;
+            ssdgs->spielerFarbe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->teamFarbe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->gewonneneRunden = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->punkte = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->linienLänge = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->zeitAmLeben = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->zeitTod = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->kills = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->tode = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            gss->add( ssdgs );
+        }
+        break;
+    case 3: // Gesammt Team Statistik
+        if( 1 )
+        {
+            SSDGesamtTeam *ssdgt = new SSDGesamtTeam();
+            ssdgt->teamNummer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            char tnlän = *bytes;
+            län--;
+            bytes++;
+            char *txt = new char[ tnlän + 1 ];
+            txt[ tnlän ] = 0;
+            for( int i = 0; i < tnlän; i++ )
+                txt[ i ] = bytes[ i ];
+            bytes += tnlän;
+            län -= tnlän;
+            ssdgt->teamName = txt;
+            delete[] txt;
+            ssdgt->teamFarbe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->gewonneneRunden = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->punkte = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->linienLänge = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->kills = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->tode = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            gts->add( ssdgt );
+        }
+        break;
+    case 4: // Runde Statistik
+        if( 1 )
+        {
+            SSDRunde *ssdr = new SSDRunde();
+            ssdr->rundenNummer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdr->rundenDauer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdr->rundenSieger = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdr->spielfeldNutzung = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int breite = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int höhe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdr->rundenBild.neuBild( breite, höhe, 0 );
+            rs->add( ssdr );
+        }
+        break;
+    case 5: // Runde Bild
+        if( 1 )
+        {
+            int runde = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int *buff = 0;
+            int max = 0;
+            int anz = rs->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                if( rs->hat( i ) && rs->get( i )->rundenNummer == runde )
+                {
+                    buff = rs->get( i )->rundenBild.getBuffer();
+                    max = rs->get( i )->rundenBild.getBreite() * rs->get( i )->rundenBild.getHeight();
+                    break;
+                }
+            }
+            if( !buff )
+                break;
+            int index = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int plän = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            for( int i = 0; i < plän; i++ )
+            {
+                if( index + i >= max )
+                    break;
+                buff[ index + i ] = *(int *)bytes;
+                bytes += 4;
+                län -= 4;
+            }
+        }
+        break;
+    case 6: // Runde Spieler Statistik
+        if( 1 )
+        {
+            int runde = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int anz = rs->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                if( rs->hat( i ) && rs->get( i )->rundenNummer == runde )
+                {
+                    SSDRundeSpieler *ssdrs = new SSDRundeSpieler();
+                    ssdrs->spielerNummer = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    char snlän = *bytes;
+                    län--;
+                    bytes++;
+                    char *txt = new char[ snlän + 1 ];
+                    txt[ snlän ] = 0;
+                    for( int j = 0; j < snlän; j++ )
+                        txt[ j ] = bytes[ j ];
+                    bytes += snlän;
+                    län -= snlän;
+                    ssdrs->spielerName = txt;
+                    delete[] txt;
+                    char tnlän = *bytes;
+                    län--;
+                    bytes++;
+                    txt = new char[ tnlän + 1 ];
+                    txt[ tnlän ] = 0;
+                    for( int j = 0; j < tnlän; j++ )
+                        txt[ j ] = bytes[ j ];
+                    bytes += tnlän;
+                    län -= tnlän;
+                    ssdrs->teamName = txt;
+                    delete[] txt;
+                    ssdrs->spielerFarbe = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrs->teamFarbe = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrs->linienLänge = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrs->kills = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrs->todesZeit = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    rs->get( i )->spieler.add( ssdrs );
+                    break;
+                }
+            }
+        }
+        break;
+    case 7: // Runde Team Statistik
+        if( 1 )
+        {
+            int runde = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int anz = rs->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                if( rs->hat( i ) && rs->get( i )->rundenNummer == runde )
+                {
+                    SSDRundeTeam *ssdrt = new SSDRundeTeam();
+                    ssdrt->teamNummer = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    char tnlän = *bytes;
+                    län--;
+                    bytes++;
+                    char *txt = new char[ tnlän + 1 ];
+                    txt[ tnlän ] = 0;
+                    for( int j = 0; j < tnlän; j++ )
+                        txt[ j ] = bytes[ j ];
+                    bytes += tnlän;
+                    län -= tnlän;
+                    ssdrt->teamName = txt;
+                    delete[] txt;
+                    ssdrt->teamFarbe = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrt->ergebnis = *bytes;
+                    bytes++;
+                    län--;
+                    ssdrt->linienLänge = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrt->kills = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    ssdrt->tode = *(int *)bytes;
+                    bytes += 4;
+                    län -= 4;
+                    rs->get( i )->teams.add( ssdrt );
+                    break;
+                }
+            }
+        }
+        break;
+    case 8: // Chat Nachricht
+        if( 1 )
+        {
+            int vonAccount = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            char *txt = new char[ län + 1 ];
+            txt[ län ] = 0;
+            for( int i = 0; i < län; i++ )
+                txt[ i ] = bytes[ i ];
+            if( status == 1 )
+                chat->addChatNachricht( vonAccount, txt );
+            delete[] txt;
+        }
+        break;
+    case 9: // Spieler hat verlassen
+        if( 1 )
+        {
+            int acc = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            if( status == 1 )
+                chat->spielerOffline( acc );
+        }
+        break;
+    default:
+        // Fehler
+        break;
+    }
+    if( län != 0 )
+    {
+        // Fehler
+    }
+    unlock();
 }
 
 void SpielStatistik::doPublicMausEreignis( MausEreignis &me )
 {
-	if( !status )
-		return;
-	lock();
-	if( status == 1 )
-	{
-		tabelle->doPublicMausEreignis( me );
-		runde->doPublicMausEreignis( me );
-		chat->doPublicMausEreignis( me );
-	}
-	unlock();
+    if( !status )
+        return;
+    lock();
+    if( status == 1 )
+    {
+        tabelle->doPublicMausEreignis( me );
+        runde->doPublicMausEreignis( me );
+        chat->doPublicMausEreignis( me );
+    }
+    unlock();
 }
 
 void SpielStatistik::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( !status )
-		return;
-	lock();
-	if( status == 1 )
-		chat->doTastaturEreignis( te );
-	unlock();
+    if( !status )
+        return;
+    lock();
+    if( status == 1 )
+        chat->doTastaturEreignis( te );
+    unlock();
 }
 
 bool SpielStatistik::tick( double zeit )
 {
-	if( !status )
-		return 0;
-	lock();
-	if( status == 1 )
-	{
-		rend |= chat->tick( zeit );
-		rend |= runde->tick( zeit );
-		rend |= tabelle->tick( zeit );
-		if( ( chat->hatVerlassen() || runde->mussVerlassen() ) && status == 1 )
-		{
-			spielc->trenne();
-			status = 2;
-		}
-		runde->setRunde( tabelle->getRunde() );
-	}
-	bool ret = rend;
-	rend = 0;
-	unlock();
-	return ret;
+    if( !status )
+        return 0;
+    lock();
+    if( status == 1 )
+    {
+        rend |= chat->tick( zeit );
+        rend |= runde->tick( zeit );
+        rend |= tabelle->tick( zeit );
+        if( ( chat->hatVerlassen() || runde->mussVerlassen() ) && status == 1 )
+        {
+            spielc->trenne();
+            status = 2;
+        }
+        runde->setRunde( tabelle->getRunde() );
+    }
+    bool ret = rend;
+    rend = 0;
+    unlock();
+    return ret;
 }
 
 void SpielStatistik::render( Bild &zRObj )
 {
-	if( !status )
-		return;
-	lock();
-	chat->render( zRObj );
-	runde->render( zRObj );
-	tabelle->render( zRObj );
-	unlock();
+    if( !status )
+        return;
+    lock();
+    chat->render( zRObj );
+    runde->render( zRObj );
+    tabelle->render( zRObj );
+    unlock();
 }
 
 void SpielStatistik::verlassen()
 {
-	if( spielc )
-	    spielc->trenne();
-	status = 2;
+    if( spielc )
+        spielc->trenne();
+    status = 2;
 }
 
 // constant
 int SpielStatistik::getStatus() const // 0 = laden, 1 = läuft, 2 = fortsetzen
 {
-	return status;
+    return status;
 }
 
 // Reference Counting
 SpielStatistikV *SpielStatistik::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 SpielStatistikV *SpielStatistik::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Linie/SpielStatistik/Tabelle/StatistikTabelle.cpp

@@ -6,766 +6,766 @@
 
 // Inhalt der StatistikTabelle Klasse aus StatistikTabelle.h
 // Konstruktor
-StatistikTabelle::StatistikTabelle( Array< SSDGesamtSpieler* > *ssdgs, Array< SSDGesamtTeam* > *ssdgt,
-									Array< SSDRunde* > *ssdr, Schrift *zSchrift, Bildschirm *zScreen, bool historie )
-: schrift( zSchrift->getThis() ),
-  ssdgs( ssdgs ),
-  ssdgt( ssdgt ),
-  ssdr( ssdr ),
-  stAuswahl( initAuswahlBox( 10, 10, 120, 20, zSchrift, ABSTYLE, { "Spieler", "Teams" } ) ),
-  grAuswahl( initAuswahlBox( 140, 10, 120, 20, zSchrift, ABSTYLE, { "Gesamt" } ) ),
-  sortAuswahlGS( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe", "Teamfarbe",
-																		"Gewonnene Runden", "Punkte", "Linienlänge", "Zeit am Leben",
-																		"Zeit tod", "Kills", "Tode" } ) ),
-  sortAuswahlGT( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe", "Gewonnene Runden", "Punkte",
-																		"Linienlänge", "Kills", "Tode" } ) ),
-  sortAuswahlRS( new RCArray< AuswahlBox >() ),
-  sortAuswahlRT( new RCArray< AuswahlBox >() ),
-  sortRichtungGS( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
-  sortRichtungGT( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
-  sortRichtungRS( new RCArray< AuswahlBox >() ),
-  sortRichtungRT( new RCArray< AuswahlBox >() ),
-  gesamtSpieler( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Spielername", 120, 20, 200 }, { "Teamname", 120, 20, 120 },
-  { "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 }, { "Gewonnene Runden", 130, 20, 130 }, { "Punkte", 50, 20, 50 },
-  { "Linienlänge", 120, 20, 120 }, { "Zeit Am Leben", 120, 20, 120 }, { "Zeit tod", 60, 20, 60 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
-  gesamtTeam( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Teamname", 120, 20, 120 }, { "Teamfarbe", 100, 20, 100 },
-  { "Gewonnene Runden", 130, 20, 130 }, { "Punkte", 50, 20, 50 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
-  rundeSpieler( new RCArray< ObjTabelle >() ),
-  rundeTeam( new RCArray< ObjTabelle >() ),
-  teamS( 0 ),
-  rundeAusw( -1 ),
-  rend( 0 ),
-  ref( 1 )
+StatistikTabelle::StatistikTabelle( Array< SSDGesamtSpieler * > *ssdgs, Array< SSDGesamtTeam * > *ssdgt,
+                                    Array< SSDRunde * > *ssdr, Schrift *zSchrift, Bildschirm *zScreen, bool historie )
+    : schrift( dynamic_cast<Schrift *>( zSchrift->getThis() ) ),
+    ssdgs( ssdgs ),
+    ssdgt( ssdgt ),
+    ssdr( ssdr ),
+    stAuswahl( initAuswahlBox( 10, 10, 120, 20, zSchrift, ABSTYLE, { "Spieler", "Teams" } ) ),
+    grAuswahl( initAuswahlBox( 140, 10, 120, 20, zSchrift, ABSTYLE, { "Gesamt" } ) ),
+    sortAuswahlGS( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe", "Teamfarbe",
+                                                                          "Gewonnene Runden", "Punkte", "Linienlänge", "Zeit am Leben",
+                                                                          "Zeit tod", "Kills", "Tode" } ) ),
+    sortAuswahlGT( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe", "Gewonnene Runden", "Punkte",
+                                                                          "Linienlänge", "Kills", "Tode" } ) ),
+    sortAuswahlRS( new RCArray< AuswahlBox >() ),
+    sortAuswahlRT( new RCArray< AuswahlBox >() ),
+    sortRichtungGS( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
+    sortRichtungGT( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
+    sortRichtungRS( new RCArray< AuswahlBox >() ),
+    sortRichtungRT( new RCArray< AuswahlBox >() ),
+    gesamtSpieler( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Spielername", 120, 20, 200 }, { "Teamname", 120, 20, 120 },
+    { "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 }, { "Gewonnene Runden", 130, 20, 130 }, { "Punkte", 50, 20, 50 },
+    { "Linienlänge", 120, 20, 120 }, { "Zeit Am Leben", 120, 20, 120 }, { "Zeit tod", 60, 20, 60 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
+    gesamtTeam( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Teamname", 120, 20, 120 }, { "Teamfarbe", 100, 20, 100 },
+    { "Gewonnene Runden", 130, 20, 130 }, { "Punkte", 50, 20, 50 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
+    rundeSpieler( new RCArray< ObjTabelle >() ),
+    rundeTeam( new RCArray< ObjTabelle >() ),
+    teamS( 0 ),
+    rundeAusw( -1 ),
+    rend( 0 ),
+    ref( 1 )
 {
-	tabelleFüllen( gesamtSpieler );
-	tabelleFüllen( gesamtTeam );
-	int anz = ssdr->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( !ssdr->hat( i ) )
-			continue;
-		Text rName( "Runde " );
-		rName += ssdr->get( i )->rundenNummer + 1;
-		grAuswahl->addEintrag( rName );
-		AuswahlBox *ab = initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe",
-										 "Teamfarbe", "Linienlänge", "Kills", "Todeszeit" } );
-		initToolTip( ab, "Spalte nach der sortiert werden soll.", schrift, zScreen );
-		sortAuswahlRS->add( ab );
-		ab = initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe", "Ergebnis",
-							 "Linienlänge", "Kills", "Tode" } );
-		initToolTip( ab, "Spalte nach der sortiert werden soll.", schrift, zScreen );
-		sortAuswahlRT->add( ab );
-		ab = initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } );
-		initToolTip( ab, "Richtung nach der sortiert werden soll.", schrift, zScreen );
-		sortRichtungRS->add( ab );
-		ab = initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } );
-		initToolTip( ab, "Richtung nach der sortiert werden soll.", schrift, zScreen );
-		sortRichtungRT->add( ab );
-		rundeSpieler->add( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Spielername", 120, 20, 200 }, { "Teamname", 120, 20, 120 },
-		{ "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Todeszeit", 80, 20, 80 } }, 20 ) );
-		rundeTeam->add( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Teamname", 120, 20, 120 }, { "Teamfarbe", 100, 20, 100 },
-		{ "Ergebnis", 80, 20, 80 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) );
-		tabelleFüllen( rundeSpieler->z( i ) );
-		tabelleFüllen( rundeTeam->z( i ) );
-	}
-	if( historie )
-	{
-		sortRichtungGS->setSize( 110, 20 );
-		sortRichtungGT->setSize( 110, 20 );
-		gesamtSpieler->setSize( 500, 380 );
-		gesamtTeam->setSize( 500, 380 );
-		for( int i = 0; i < anz; i++ )
-		{
-			rundeSpieler->z( i )->setSize( 500, 380 );
-			rundeTeam->z( i )->setSize( 500, 380 );
-			sortRichtungRS->z( i )->setSize( 110, 20 );
-			sortRichtungRT->z( i )->setSize( 110, 20 );
-		}
-	}
+    tabelleFüllen( gesamtSpieler );
+    tabelleFüllen( gesamtTeam );
+    int anz = ssdr->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( !ssdr->hat( i ) )
+            continue;
+        Text rName( "Runde " );
+        rName += ssdr->get( i )->rundenNummer + 1;
+        grAuswahl->addEintrag( rName );
+        AuswahlBox *ab = initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe",
+                                         "Teamfarbe", "Linienlänge", "Kills", "Todeszeit" } );
+        initToolTip( ab, "Spalte nach der sortiert werden soll.", schrift, zScreen );
+        sortAuswahlRS->add( ab );
+        ab = initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe", "Ergebnis",
+                             "Linienlänge", "Kills", "Tode" } );
+        initToolTip( ab, "Spalte nach der sortiert werden soll.", schrift, zScreen );
+        sortAuswahlRT->add( ab );
+        ab = initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } );
+        initToolTip( ab, "Richtung nach der sortiert werden soll.", schrift, zScreen );
+        sortRichtungRS->add( ab );
+        ab = initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } );
+        initToolTip( ab, "Richtung nach der sortiert werden soll.", schrift, zScreen );
+        sortRichtungRT->add( ab );
+        rundeSpieler->add( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Spielername", 120, 20, 200 }, { "Teamname", 120, 20, 120 },
+        { "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Todeszeit", 80, 20, 80 } }, 20 ) );
+        rundeTeam->add( initObjTabelle( 10, 40, 500, 245, zSchrift, OTSTYLE, { { "Teamname", 120, 20, 120 }, { "Teamfarbe", 100, 20, 100 },
+        { "Ergebnis", 80, 20, 80 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) );
+        tabelleFüllen( rundeSpieler->z( i ) );
+        tabelleFüllen( rundeTeam->z( i ) );
+    }
+    if( historie )
+    {
+        sortRichtungGS->setSize( 110, 20 );
+        sortRichtungGT->setSize( 110, 20 );
+        gesamtSpieler->setSize( 500, 380 );
+        gesamtTeam->setSize( 500, 380 );
+        for( int i = 0; i < anz; i++ )
+        {
+            rundeSpieler->z( i )->setSize( 500, 380 );
+            rundeTeam->z( i )->setSize( 500, 380 );
+            sortRichtungRS->z( i )->setSize( 110, 20 );
+            sortRichtungRT->z( i )->setSize( 110, 20 );
+        }
+    }
 }
 
 // Destruktor
 StatistikTabelle::~StatistikTabelle()
 {
-	tabelleLehren( gesamtSpieler, 1 );
-	tabelleLehren( gesamtTeam, 1 );
-	int anz = rundeSpieler->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-		tabelleLehren( rundeSpieler->z( i ), 1 );
-	anz = rundeTeam->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-		tabelleLehren( rundeTeam->z( i ), 1 );
-	schrift->release();
-	ssdgs->release();
-	ssdgt->release();
-	ssdr->release();
-	stAuswahl->release();
-	grAuswahl->release();
-	sortAuswahlGS->release();
-	sortAuswahlGT->release();
-	sortAuswahlRS->release();
-	sortAuswahlRT->release();
-	sortRichtungGS->release();
-	sortRichtungGT->release();
-	sortRichtungRS->release();
-	sortRichtungRT->release();
-	gesamtSpieler->release();
-	gesamtTeam->release();
-	rundeSpieler->release();
-	rundeTeam->release();
+    tabelleLehren( gesamtSpieler, 1 );
+    tabelleLehren( gesamtTeam, 1 );
+    int anz = rundeSpieler->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+        tabelleLehren( rundeSpieler->z( i ), 1 );
+    anz = rundeTeam->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+        tabelleLehren( rundeTeam->z( i ), 1 );
+    schrift->release();
+    ssdgs->release();
+    ssdgt->release();
+    ssdr->release();
+    stAuswahl->release();
+    grAuswahl->release();
+    sortAuswahlGS->release();
+    sortAuswahlGT->release();
+    sortAuswahlRS->release();
+    sortAuswahlRT->release();
+    sortRichtungGS->release();
+    sortRichtungGT->release();
+    sortRichtungRS->release();
+    sortRichtungRT->release();
+    gesamtSpieler->release();
+    gesamtTeam->release();
+    rundeSpieler->release();
+    rundeTeam->release();
 }
 
 // privat
 void StatistikTabelle::tabelleLehren( ObjTabelle *zT, bool überschrift )
 {
-	int zAnz = zT->getZeilenAnzahl();
-	for( int i = !überschrift; i < zAnz; i++ )
-		zT->removeZeile( !überschrift );
+    int zAnz = zT->getZeilenAnzahl();
+    for( int i = !überschrift; i < zAnz; i++ )
+        zT->removeZeile( !überschrift );
 }
 
 void StatistikTabelle::tabelleFüllen( ObjTabelle *zT )
 {
-	if( zT == gesamtSpieler )
-	{
-		if( !sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() ) )
-			return;
-		if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
-			return;
-		Array< int > reihenfolge;
-		bool aufsteigend = sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() )->istGleich( "Aufwärts" );
-		int anz = ssdgs->getEintragAnzahl();
-		bool *fertig = new bool[ anz ];
-		ZeroMemory( fertig, anz );
-		bool spielername = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielername" );
-		bool teamname = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamname" );
-		bool spielerfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielerfarbe" );
-		bool teamfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamfarbe" );
-		bool gewonnenerunden = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Gewonnene Runden" );
-		bool punkte = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Punkte" );
-		bool linienlänge = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Linienlänge" );
-		bool zeitamleben = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit am Leben" );
-		bool zeittod = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit tod" );
-		bool kills = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Kills" );
-		bool tode = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Tode" );
-		for( int i = 0; i < anz; i++ )
-		{
-			Text minMaxT;
-			int minMax;
-			int pos = -1;
-			for( int j = 0; j < anz; j++ )
-			{
-				if( !ssdgs->hat( j ) || fertig[ j ] )
-					continue;
-				if( spielername && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->spielerName > minMaxT ) ) )
-				{ // Sortiert nach Spieler Name
-					minMaxT = ssdgs->get( j )->spielerName.getText();
-					pos = j;
-				}
-				if( teamname && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->teamName > minMaxT ) ) )
-				{ // Sortiert nach Team Name
-					minMaxT = ssdgs->get( j )->teamName.getText();
-					pos = j;
-				}
-				if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->spielerFarbe > minMax ) ) )
-				{ // Sortiert nach Spieler Farbe
-					minMax = ssdgs->get( j )->spielerFarbe;
-					pos = j;
-				}
-				if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->teamFarbe > minMax ) ) )
-				{ // Sortiert nach Team Farbe
-					minMax = ssdgs->get( j )->teamFarbe;
-					pos = j;
-				}
-				if( gewonnenerunden && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->gewonneneRunden < minMax ) || ( !aufsteigend && ssdgs->get( j )->gewonneneRunden > minMax ) ) )
-				{ // Sortiert nach Gewonnenen Runden
-					minMax = ssdgs->get( j )->gewonneneRunden;
-					pos = j;
-				}
-				if( punkte && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgs->get( j )->punkte > minMax ) ) )
-				{ // Sortiert nach Punkten
-					minMax = ssdgs->get( j )->punkte;
-					pos = j;
-				}
-				if( linienlänge && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdgs->get( j )->linienLänge > minMax ) ) )
-				{ // Sortiert nach Linienlängen
-					minMax = ssdgs->get( j )->linienLänge;
-					pos = j;
-				}
-				if( zeitamleben && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitAmLeben < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitAmLeben > minMax ) ) )
-				{ // Sortiert nach Zeit Am Leben
-					minMax = ssdgs->get( j )->zeitAmLeben;
-					pos = j;
-				}
-				if( zeittod && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitTod < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitTod > minMax ) ) )
-				{ // Sortiert nach Zeit Tod
-					minMax = ssdgs->get( j )->zeitTod;
-					pos = j;
-				}
-				if( kills && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->kills < minMax ) || ( !aufsteigend && ssdgs->get( j )->kills > minMax ) ) )
-				{ // Sortiert nach Kills
-					minMax = ssdgs->get( j )->kills;
-					pos = j;
-				}
-				if( tode && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->tode < minMax ) || ( !aufsteigend && ssdgs->get( j )->tode > minMax ) ) )
-				{ // Sortiert nach Toden
-					minMax = ssdgs->get( j )->tode;
-					pos = j;
-				}
-			}
-			if( pos >= 0 )
-			{
-				reihenfolge.add( pos );
-				fertig[ pos ] = 1;
-			}
-			else
-				break;
-		}
-		delete[] fertig;
-		anz = reihenfolge.getEintragAnzahl();
-		for( int j = 0; j < anz; j++ )
-		{
-			int i = reihenfolge.get( j );
-			zT->addZeile( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
-			int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->spielerName ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->teamName ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->spielerFarbe );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->teamFarbe );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Gewonnene Runden" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->gewonneneRunden ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->linienLänge ) );
-			Text zeitAmLeben;
-			zeitAmLeben += ssdgs->get( i )->zeitAmLeben / 60;
-			zeitAmLeben += ":";
-			zeitAmLeben += ssdgs->get( i )->zeitAmLeben % 60;
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit Am Leben" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitAmLeben ) );
-			Text zeitTod;
-			zeitTod += ssdgs->get( i )->zeitTod / 60;
-			zeitTod += ":";
-			zeitTod += ssdgs->get( i )->zeitTod % 60;
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit tod" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitTod ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->tode ) );
-		}
-		return;
-	}
-	if( zT == gesamtTeam )
-	{
-		if( !sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() ) )
-			return;
-		if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
-			return;
-		Array< int > reihenfolge;
-		bool aufsteigend = sortRichtungGT->zEintragText( sortRichtungGT->getAuswahl() )->istGleich( "Aufwärts" );
-		int anz = ssdgt->getEintragAnzahl();
-		bool *fertig = new bool[ anz ];
-		ZeroMemory( fertig, anz );
-		bool teamname = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamname" );
-		bool teamfarbe = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamfarbe" );
-		bool gewonnenerunden = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Gewonnene Runden" );
-		bool punkte = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Punkte" );
-		bool linienlänge = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Linienlänge" );
-		bool kills = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Kills" );
-		bool tode = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Tode" );
-		for( int i = 0; i < anz; i++ )
-		{
-			Text minMaxT;
-			int minMax;
-			int pos = -1;
-			for( int j = 0; j < anz; j++ )
-			{
-				if( !ssdgt->hat( j ) || fertig[ j ] )
-					continue;
-				if( teamname && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgt->get( j )->teamName > minMaxT ) ) )
-				{ // Sortiert nach Team Name
-					minMaxT = ssdgt->get( j )->teamName.getText();
-					pos = j;
-				}
-				if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgt->get( j )->teamFarbe > minMax ) ) )
-				{ // Sortiert nach Team Farbe
-					minMax = ssdgt->get( j )->teamFarbe;
-					pos = j;
-				}
-				if( gewonnenerunden && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->gewonneneRunden < minMax ) || ( !aufsteigend && ssdgt->get( j )->gewonneneRunden > minMax ) ) )
-				{ // Sortiert nach Gewonnenen Runden
-					minMax = ssdgt->get( j )->gewonneneRunden;
-					pos = j;
-				}
-				if( punkte && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgt->get( j )->punkte > minMax ) ) )
-				{ // Sortiert nach Punkten
-					minMax = ssdgt->get( j )->punkte;
-					pos = j;
-				}
-				if( linienlänge && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdgt->get( j )->linienLänge > minMax ) ) )
-				{ // Sortiert nach Linienlängen
-					minMax = ssdgt->get( j )->linienLänge;
-					pos = j;
-				}
-				if( kills && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->kills < minMax ) || ( !aufsteigend && ssdgt->get( j )->kills > minMax ) ) )
-				{ // Sortiert nach Kills
-					minMax = ssdgt->get( j )->kills;
-					pos = j;
-				}
-				if( tode && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->tode < minMax ) || ( !aufsteigend && ssdgt->get( j )->tode > minMax ) ) )
-				{ // Sortiert nach Toden
-					minMax = ssdgt->get( j )->tode;
-					pos = j;
-				}
-			}
-			if( pos >= 0 )
-			{
-				reihenfolge.add( pos );
-				fertig[ pos ] = 1;
-			}
-			else
-				break;
-		}
-		delete[] fertig;
-		anz = reihenfolge.getEintragAnzahl();
-		for( int j = 0; j < anz; j++ )
-		{
-			int i = reihenfolge.get( j );
-			zT->addZeile( Text( "Team " ) += ssdgt->get( i )->teamNummer );
-			int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdgt->get( i )->teamNummer );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgt->get( i )->teamName ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgt->get( i )->teamFarbe );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Gewonnene Runden" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->gewonneneRunden ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->punkte ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->linienLänge ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->kills ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->tode ) );
-		}
-		return;
-	}
-	int anz = rundeSpieler->getEintragAnzahl();
-	for( int h = 0; h < anz; h++ )
-	{
-		if( zT == rundeSpieler->z( h ) )
-		{
-			if( !ssdr->hat( h ) )
-				return;
-			Array< SSDRundeSpieler* > *ssdrs = &ssdr->get( h )->spieler;
-			AuswahlBox *sortAuswahl = sortAuswahlRS->z( h );
-			AuswahlBox *sortRichtung = sortRichtungRS->z( h );
-			if( !sortAuswahl || !sortAuswahl->zEintragText( sortAuswahl->getAuswahl() ) )
-				return;
-			if( !sortRichtung || !sortRichtung->zEintragText( sortRichtung->getAuswahl() ) )
-				return;
-			Array< int > reihenfolge;
-			bool aufsteigend = sortRichtung->zEintragText( sortRichtung->getAuswahl() )->istGleich( "Aufwärts" );
-			int anz = ssdrs->getEintragAnzahl();
-			bool *fertig = new bool[ anz ];
-			ZeroMemory( fertig, anz );
-			bool spielername = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Spielername" );
-			bool teamname = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamname" );
-			bool spielerfarbe = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Spielerfarbe" );
-			bool teamfarbe = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamfarbe" );
-			bool linienlänge = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Linienlänge" );
-			bool kills = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Kills" );
-			bool todeszeit = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Todeszeit" );
-			for( int i = 0; i < anz; i++ )
-			{
-				Text minMaxT;
-				int minMax;
-				int pos = -1;
-				for( int j = 0; j < anz; j++ )
-				{
-					if( !ssdrs->hat( j ) || fertig[ j ] )
-						continue;
-					if( spielername && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdrs->get( j )->spielerName > minMaxT ) ) )
-					{ // Sortiert nach Spieler Name
-						minMaxT = ssdrs->get( j )->spielerName.getText();
-						pos = j;
-					}
-					if( teamname && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdrs->get( j )->teamName > minMaxT ) ) )
-					{ // Sortiert nach Team Name
-						minMaxT = ssdrs->get( j )->teamName.getText();
-						pos = j;
-					}
-					if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdrs->get( j )->spielerFarbe > minMax ) ) )
-					{ // Sortiert nach Spieler Farbe
-						minMax = ssdrs->get( j )->spielerFarbe;
-						pos = j;
-					}
-					if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdrs->get( j )->teamFarbe > minMax ) ) )
-					{ // Sortiert nach Team Farbe
-						minMax = ssdrs->get( j )->teamFarbe;
-						pos = j;
-					}
-					if( linienlänge && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdrs->get( j )->linienLänge > minMax ) ) )
-					{ // Sortiert nach Linienlängen
-						minMax = ssdrs->get( j )->linienLänge;
-						pos = j;
-					}
-					if( kills && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->kills < minMax ) || ( !aufsteigend && ssdrs->get( j )->kills > minMax ) ) )
-					{ // Sortiert nach Kills
-						minMax = ssdrs->get( j )->kills;
-						pos = j;
-					}
-					if( todeszeit && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->todesZeit < minMax ) || ( !aufsteigend && ssdrs->get( j )->todesZeit > minMax ) ) )
-					{ // Sortiert nach Todeszeitpunkten
-						minMax = ssdrs->get( j )->todesZeit;
-						pos = j;
-					}
-				}
-				if( pos >= 0 )
-				{
-					reihenfolge.add( pos );
-					fertig[ pos ] = 1;
-				}
-				else
-					break;
-			}
-			delete[] fertig;
-			anz = reihenfolge.getEintragAnzahl();
-			for( int j = 0; j < anz; j++ )
-			{
-				int i = reihenfolge.get( j );
-				zT->addZeile( Text( "Spieler " ) += ssdrs->get( i )->spielerNummer );
-				int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdrs->get( i )->spielerNummer );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrs->get( i )->spielerName ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrs->get( i )->teamName ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-				( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdrs->get( i )->spielerFarbe );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-				( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdrs->get( i )->teamFarbe );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrs->get( i )->linienLänge ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrs->get( i )->kills ) );
-				Text todesZeit;
-				todesZeit += ssdrs->get( i )->todesZeit / 60;
-				todesZeit += ":";
-				todesZeit += ssdrs->get( i )->todesZeit % 60;
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Todeszeit" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, todesZeit ) );
-			}
-			return;
-		}
-	}
-	anz = rundeTeam->getEintragAnzahl();
-	for( int h = 0; h < anz; h++ )
-	{
-		if( zT == rundeTeam->z( h ) )
-		{
-			if( !ssdr->hat( h ) )
-				return;
-			Array< SSDRundeTeam* > *ssdrt = &ssdr->get( h )->teams;
-			AuswahlBox *sortAuswahl = sortAuswahlRT->z( h );
-			AuswahlBox *sortRichtung = sortRichtungRT->z( h );
-			if( !sortAuswahl || !sortAuswahl->zEintragText( sortAuswahl->getAuswahl() ) )
-				return;
-			if( !sortRichtung || !sortRichtung->zEintragText( sortRichtung->getAuswahl() ) )
-				return;
-			Array< int > reihenfolge;
-			bool aufsteigend = sortRichtung->zEintragText( sortRichtung->getAuswahl() )->istGleich( "Aufwärts" );
-			int anz = ssdrt->getEintragAnzahl();
-			bool *fertig = new bool[ anz ];
-			ZeroMemory( fertig, anz );
-			bool teamname = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamname" );
-			bool teamfarbe = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamfarbe" );
-			bool ergebnis = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Ergebnis" );
-			bool linienlänge = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Linienlänge" );
-			bool kills = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Kills" );
-			bool tode = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Tode" );
-			for( int i = 0; i < anz; i++ )
-			{
-				Text minMaxT;
-				int minMax;
-				int pos = -1;
-				for( int j = 0; j < anz; j++ )
-				{
-					if( !ssdrt->hat( j ) || fertig[ j ] )
-						continue;
-					if( teamname && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdrt->get( j )->teamName > minMaxT ) ) )
-					{ // Sortiert nach Team Name
-						minMaxT = ssdrt->get( j )->teamName.getText();
-						pos = j;
-					}
-					if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdrt->get( j )->teamFarbe > minMax ) ) )
-					{ // Sortiert nach Team Farbe
-						minMax = ssdrt->get( j )->teamFarbe;
-						pos = j;
-					}
-					if( ergebnis && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->ergebnis < minMax ) || ( !aufsteigend && ssdrt->get( j )->ergebnis > minMax ) ) )
-					{ // Sortiert nach Ergebnis
-						minMax = ssdrt->get( j )->ergebnis;
-						pos = j;
-					}
-					if( linienlänge && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdrt->get( j )->linienLänge > minMax ) ) )
-					{ // Sortiert nach Linienlängen
-						minMax = ssdrt->get( j )->linienLänge;
-						pos = j;
-					}
-					if( kills && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->kills < minMax ) || ( !aufsteigend && ssdrt->get( j )->kills > minMax ) ) )
-					{ // Sortiert nach Kills
-						minMax = ssdrt->get( j )->kills;
-						pos = j;
-					}
-					if( tode && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->tode < minMax ) || ( !aufsteigend && ssdrt->get( j )->tode > minMax ) ) )
-					{ // Sortiert nach Todeszeitpunkten
-						minMax = ssdrt->get( j )->tode;
-						pos = j;
-					}
-				}
-				if( pos >= 0 )
-				{
-					reihenfolge.add( pos );
-					fertig[ pos ] = 1;
-				}
-				else
-					break;
-			}
-			delete[] fertig;
-			anz = reihenfolge.getEintragAnzahl();
-			for( int j = 0; j < anz; j++ )
-			{
-				int i = reihenfolge.get( j );
-				zT->addZeile( Text( "Team " ) += ssdrt->get( i )->teamNummer );
-				int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdrt->get( i )->teamNummer );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrt->get( i )->teamName ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-				( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdrt->get( i )->teamFarbe );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Ergebnis" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ergebnis ? Text( "Gewonnen" ) : Text( "Verloren" ) ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->linienLänge ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->kills ) );
-				zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->tode ) );
-			}
-			return;
-		}
-	}
+    if( zT == gesamtSpieler )
+    {
+        if( !sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() ) )
+            return;
+        if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
+            return;
+        Array< int > reihenfolge;
+        bool aufsteigend = sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() )->istGleich( "Aufwärts" );
+        int anz = ssdgs->getEintragAnzahl();
+        bool *fertig = new bool[ anz ];
+        ZeroMemory( fertig, anz );
+        bool spielername = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielername" );
+        bool teamname = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamname" );
+        bool spielerfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielerfarbe" );
+        bool teamfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamfarbe" );
+        bool gewonnenerunden = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Gewonnene Runden" );
+        bool punkte = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Punkte" );
+        bool linienlänge = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Linienlänge" );
+        bool zeitamleben = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit am Leben" );
+        bool zeittod = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit tod" );
+        bool kills = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Kills" );
+        bool tode = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Tode" );
+        for( int i = 0; i < anz; i++ )
+        {
+            Text minMaxT;
+            int minMax;
+            int pos = -1;
+            for( int j = 0; j < anz; j++ )
+            {
+                if( !ssdgs->hat( j ) || fertig[ j ] )
+                    continue;
+                if( spielername && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->spielerName > minMaxT ) ) )
+                { // Sortiert nach Spieler Name
+                    minMaxT = ssdgs->get( j )->spielerName.getText();
+                    pos = j;
+                }
+                if( teamname && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->teamName > minMaxT ) ) )
+                { // Sortiert nach Team Name
+                    minMaxT = ssdgs->get( j )->teamName.getText();
+                    pos = j;
+                }
+                if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->spielerFarbe > minMax ) ) )
+                { // Sortiert nach Spieler Farbe
+                    minMax = ssdgs->get( j )->spielerFarbe;
+                    pos = j;
+                }
+                if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->teamFarbe > minMax ) ) )
+                { // Sortiert nach Team Farbe
+                    minMax = ssdgs->get( j )->teamFarbe;
+                    pos = j;
+                }
+                if( gewonnenerunden && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->gewonneneRunden < minMax ) || ( !aufsteigend && ssdgs->get( j )->gewonneneRunden > minMax ) ) )
+                { // Sortiert nach Gewonnenen Runden
+                    minMax = ssdgs->get( j )->gewonneneRunden;
+                    pos = j;
+                }
+                if( punkte && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgs->get( j )->punkte > minMax ) ) )
+                { // Sortiert nach Punkten
+                    minMax = ssdgs->get( j )->punkte;
+                    pos = j;
+                }
+                if( linienlänge && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdgs->get( j )->linienLänge > minMax ) ) )
+                { // Sortiert nach Linienlängen
+                    minMax = ssdgs->get( j )->linienLänge;
+                    pos = j;
+                }
+                if( zeitamleben && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitAmLeben < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitAmLeben > minMax ) ) )
+                { // Sortiert nach Zeit Am Leben
+                    minMax = ssdgs->get( j )->zeitAmLeben;
+                    pos = j;
+                }
+                if( zeittod && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitTod < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitTod > minMax ) ) )
+                { // Sortiert nach Zeit Tod
+                    minMax = ssdgs->get( j )->zeitTod;
+                    pos = j;
+                }
+                if( kills && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->kills < minMax ) || ( !aufsteigend && ssdgs->get( j )->kills > minMax ) ) )
+                { // Sortiert nach Kills
+                    minMax = ssdgs->get( j )->kills;
+                    pos = j;
+                }
+                if( tode && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->tode < minMax ) || ( !aufsteigend && ssdgs->get( j )->tode > minMax ) ) )
+                { // Sortiert nach Toden
+                    minMax = ssdgs->get( j )->tode;
+                    pos = j;
+                }
+            }
+            if( pos >= 0 )
+            {
+                reihenfolge.add( pos );
+                fertig[ pos ] = 1;
+            }
+            else
+                break;
+        }
+        delete[] fertig;
+        anz = reihenfolge.getEintragAnzahl();
+        for( int j = 0; j < anz; j++ )
+        {
+            int i = reihenfolge.get( j );
+            zT->addZeile( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
+            int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->spielerName ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->teamName ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+            ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->spielerFarbe );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+            ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->teamFarbe );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Gewonnene Runden" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->gewonneneRunden ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->linienLänge ) );
+            Text zeitAmLeben;
+            zeitAmLeben += ssdgs->get( i )->zeitAmLeben / 60;
+            zeitAmLeben += ":";
+            zeitAmLeben += ssdgs->get( i )->zeitAmLeben % 60;
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit Am Leben" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitAmLeben ) );
+            Text zeitTod;
+            zeitTod += ssdgs->get( i )->zeitTod / 60;
+            zeitTod += ":";
+            zeitTod += ssdgs->get( i )->zeitTod % 60;
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit tod" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitTod ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->tode ) );
+        }
+        return;
+    }
+    if( zT == gesamtTeam )
+    {
+        if( !sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() ) )
+            return;
+        if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
+            return;
+        Array< int > reihenfolge;
+        bool aufsteigend = sortRichtungGT->zEintragText( sortRichtungGT->getAuswahl() )->istGleich( "Aufwärts" );
+        int anz = ssdgt->getEintragAnzahl();
+        bool *fertig = new bool[ anz ];
+        ZeroMemory( fertig, anz );
+        bool teamname = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamname" );
+        bool teamfarbe = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamfarbe" );
+        bool gewonnenerunden = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Gewonnene Runden" );
+        bool punkte = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Punkte" );
+        bool linienlänge = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Linienlänge" );
+        bool kills = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Kills" );
+        bool tode = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Tode" );
+        for( int i = 0; i < anz; i++ )
+        {
+            Text minMaxT;
+            int minMax;
+            int pos = -1;
+            for( int j = 0; j < anz; j++ )
+            {
+                if( !ssdgt->hat( j ) || fertig[ j ] )
+                    continue;
+                if( teamname && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgt->get( j )->teamName > minMaxT ) ) )
+                { // Sortiert nach Team Name
+                    minMaxT = ssdgt->get( j )->teamName.getText();
+                    pos = j;
+                }
+                if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgt->get( j )->teamFarbe > minMax ) ) )
+                { // Sortiert nach Team Farbe
+                    minMax = ssdgt->get( j )->teamFarbe;
+                    pos = j;
+                }
+                if( gewonnenerunden && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->gewonneneRunden < minMax ) || ( !aufsteigend && ssdgt->get( j )->gewonneneRunden > minMax ) ) )
+                { // Sortiert nach Gewonnenen Runden
+                    minMax = ssdgt->get( j )->gewonneneRunden;
+                    pos = j;
+                }
+                if( punkte && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgt->get( j )->punkte > minMax ) ) )
+                { // Sortiert nach Punkten
+                    minMax = ssdgt->get( j )->punkte;
+                    pos = j;
+                }
+                if( linienlänge && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdgt->get( j )->linienLänge > minMax ) ) )
+                { // Sortiert nach Linienlängen
+                    minMax = ssdgt->get( j )->linienLänge;
+                    pos = j;
+                }
+                if( kills && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->kills < minMax ) || ( !aufsteigend && ssdgt->get( j )->kills > minMax ) ) )
+                { // Sortiert nach Kills
+                    minMax = ssdgt->get( j )->kills;
+                    pos = j;
+                }
+                if( tode && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->tode < minMax ) || ( !aufsteigend && ssdgt->get( j )->tode > minMax ) ) )
+                { // Sortiert nach Toden
+                    minMax = ssdgt->get( j )->tode;
+                    pos = j;
+                }
+            }
+            if( pos >= 0 )
+            {
+                reihenfolge.add( pos );
+                fertig[ pos ] = 1;
+            }
+            else
+                break;
+        }
+        delete[] fertig;
+        anz = reihenfolge.getEintragAnzahl();
+        for( int j = 0; j < anz; j++ )
+        {
+            int i = reihenfolge.get( j );
+            zT->addZeile( Text( "Team " ) += ssdgt->get( i )->teamNummer );
+            int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdgt->get( i )->teamNummer );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgt->get( i )->teamName ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+            ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgt->get( i )->teamFarbe );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Gewonnene Runden" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->gewonneneRunden ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->punkte ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->linienLänge ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->kills ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->tode ) );
+        }
+        return;
+    }
+    int anz = rundeSpieler->getEintragAnzahl();
+    for( int h = 0; h < anz; h++ )
+    {
+        if( zT == rundeSpieler->z( h ) )
+        {
+            if( !ssdr->hat( h ) )
+                return;
+            Array< SSDRundeSpieler * > *ssdrs = &ssdr->get( h )->spieler;
+            AuswahlBox *sortAuswahl = sortAuswahlRS->z( h );
+            AuswahlBox *sortRichtung = sortRichtungRS->z( h );
+            if( !sortAuswahl || !sortAuswahl->zEintragText( sortAuswahl->getAuswahl() ) )
+                return;
+            if( !sortRichtung || !sortRichtung->zEintragText( sortRichtung->getAuswahl() ) )
+                return;
+            Array< int > reihenfolge;
+            bool aufsteigend = sortRichtung->zEintragText( sortRichtung->getAuswahl() )->istGleich( "Aufwärts" );
+            int anz = ssdrs->getEintragAnzahl();
+            bool *fertig = new bool[ anz ];
+            ZeroMemory( fertig, anz );
+            bool spielername = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Spielername" );
+            bool teamname = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamname" );
+            bool spielerfarbe = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Spielerfarbe" );
+            bool teamfarbe = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamfarbe" );
+            bool linienlänge = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Linienlänge" );
+            bool kills = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Kills" );
+            bool todeszeit = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Todeszeit" );
+            for( int i = 0; i < anz; i++ )
+            {
+                Text minMaxT;
+                int minMax;
+                int pos = -1;
+                for( int j = 0; j < anz; j++ )
+                {
+                    if( !ssdrs->hat( j ) || fertig[ j ] )
+                        continue;
+                    if( spielername && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdrs->get( j )->spielerName > minMaxT ) ) )
+                    { // Sortiert nach Spieler Name
+                        minMaxT = ssdrs->get( j )->spielerName.getText();
+                        pos = j;
+                    }
+                    if( teamname && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdrs->get( j )->teamName > minMaxT ) ) )
+                    { // Sortiert nach Team Name
+                        minMaxT = ssdrs->get( j )->teamName.getText();
+                        pos = j;
+                    }
+                    if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdrs->get( j )->spielerFarbe > minMax ) ) )
+                    { // Sortiert nach Spieler Farbe
+                        minMax = ssdrs->get( j )->spielerFarbe;
+                        pos = j;
+                    }
+                    if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdrs->get( j )->teamFarbe > minMax ) ) )
+                    { // Sortiert nach Team Farbe
+                        minMax = ssdrs->get( j )->teamFarbe;
+                        pos = j;
+                    }
+                    if( linienlänge && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdrs->get( j )->linienLänge > minMax ) ) )
+                    { // Sortiert nach Linienlängen
+                        minMax = ssdrs->get( j )->linienLänge;
+                        pos = j;
+                    }
+                    if( kills && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->kills < minMax ) || ( !aufsteigend && ssdrs->get( j )->kills > minMax ) ) )
+                    { // Sortiert nach Kills
+                        minMax = ssdrs->get( j )->kills;
+                        pos = j;
+                    }
+                    if( todeszeit && ( pos < 0 || ( aufsteigend && ssdrs->get( j )->todesZeit < minMax ) || ( !aufsteigend && ssdrs->get( j )->todesZeit > minMax ) ) )
+                    { // Sortiert nach Todeszeitpunkten
+                        minMax = ssdrs->get( j )->todesZeit;
+                        pos = j;
+                    }
+                }
+                if( pos >= 0 )
+                {
+                    reihenfolge.add( pos );
+                    fertig[ pos ] = 1;
+                }
+                else
+                    break;
+            }
+            delete[] fertig;
+            anz = reihenfolge.getEintragAnzahl();
+            for( int j = 0; j < anz; j++ )
+            {
+                int i = reihenfolge.get( j );
+                zT->addZeile( Text( "Spieler " ) += ssdrs->get( i )->spielerNummer );
+                int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdrs->get( i )->spielerNummer );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrs->get( i )->spielerName ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrs->get( i )->teamName ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+                ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdrs->get( i )->spielerFarbe );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+                ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdrs->get( i )->teamFarbe );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrs->get( i )->linienLänge ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrs->get( i )->kills ) );
+                Text todesZeit;
+                todesZeit += ssdrs->get( i )->todesZeit / 60;
+                todesZeit += ":";
+                todesZeit += ssdrs->get( i )->todesZeit % 60;
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Todeszeit" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, todesZeit ) );
+            }
+            return;
+        }
+    }
+    anz = rundeTeam->getEintragAnzahl();
+    for( int h = 0; h < anz; h++ )
+    {
+        if( zT == rundeTeam->z( h ) )
+        {
+            if( !ssdr->hat( h ) )
+                return;
+            Array< SSDRundeTeam * > *ssdrt = &ssdr->get( h )->teams;
+            AuswahlBox *sortAuswahl = sortAuswahlRT->z( h );
+            AuswahlBox *sortRichtung = sortRichtungRT->z( h );
+            if( !sortAuswahl || !sortAuswahl->zEintragText( sortAuswahl->getAuswahl() ) )
+                return;
+            if( !sortRichtung || !sortRichtung->zEintragText( sortRichtung->getAuswahl() ) )
+                return;
+            Array< int > reihenfolge;
+            bool aufsteigend = sortRichtung->zEintragText( sortRichtung->getAuswahl() )->istGleich( "Aufwärts" );
+            int anz = ssdrt->getEintragAnzahl();
+            bool *fertig = new bool[ anz ];
+            ZeroMemory( fertig, anz );
+            bool teamname = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamname" );
+            bool teamfarbe = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Teamfarbe" );
+            bool ergebnis = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Ergebnis" );
+            bool linienlänge = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Linienlänge" );
+            bool kills = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Kills" );
+            bool tode = sortAuswahl->zEintragText( sortAuswahl->getAuswahl() )->istGleich( "Tode" );
+            for( int i = 0; i < anz; i++ )
+            {
+                Text minMaxT;
+                int minMax;
+                int pos = -1;
+                for( int j = 0; j < anz; j++ )
+                {
+                    if( !ssdrt->hat( j ) || fertig[ j ] )
+                        continue;
+                    if( teamname && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdrt->get( j )->teamName > minMaxT ) ) )
+                    { // Sortiert nach Team Name
+                        minMaxT = ssdrt->get( j )->teamName.getText();
+                        pos = j;
+                    }
+                    if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdrt->get( j )->teamFarbe > minMax ) ) )
+                    { // Sortiert nach Team Farbe
+                        minMax = ssdrt->get( j )->teamFarbe;
+                        pos = j;
+                    }
+                    if( ergebnis && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->ergebnis < minMax ) || ( !aufsteigend && ssdrt->get( j )->ergebnis > minMax ) ) )
+                    { // Sortiert nach Ergebnis
+                        minMax = ssdrt->get( j )->ergebnis;
+                        pos = j;
+                    }
+                    if( linienlänge && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->linienLänge < minMax ) || ( !aufsteigend && ssdrt->get( j )->linienLänge > minMax ) ) )
+                    { // Sortiert nach Linienlängen
+                        minMax = ssdrt->get( j )->linienLänge;
+                        pos = j;
+                    }
+                    if( kills && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->kills < minMax ) || ( !aufsteigend && ssdrt->get( j )->kills > minMax ) ) )
+                    { // Sortiert nach Kills
+                        minMax = ssdrt->get( j )->kills;
+                        pos = j;
+                    }
+                    if( tode && ( pos < 0 || ( aufsteigend && ssdrt->get( j )->tode < minMax ) || ( !aufsteigend && ssdrt->get( j )->tode > minMax ) ) )
+                    { // Sortiert nach Todeszeitpunkten
+                        minMax = ssdrt->get( j )->tode;
+                        pos = j;
+                    }
+                }
+                if( pos >= 0 )
+                {
+                    reihenfolge.add( pos );
+                    fertig[ pos ] = 1;
+                }
+                else
+                    break;
+            }
+            delete[] fertig;
+            anz = reihenfolge.getEintragAnzahl();
+            for( int j = 0; j < anz; j++ )
+            {
+                int i = reihenfolge.get( j );
+                zT->addZeile( Text( "Team " ) += ssdrt->get( i )->teamNummer );
+                int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdrt->get( i )->teamNummer );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrt->get( i )->teamName ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+                ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdrt->get( i )->teamFarbe );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Ergebnis" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ergebnis ? Text( "Gewonnen" ) : Text( "Verloren" ) ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->linienLänge ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->kills ) );
+                zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->tode ) );
+            }
+            return;
+        }
+    }
 }
 
 // nicht constant
 void StatistikTabelle::doPublicMausEreignis( MausEreignis &me )
 {
-	// Auswahl Boxen
-	int ausw = stAuswahl->getAuswahl();
-	stAuswahl->doPublicMausEreignis( me );
-	if( ausw != stAuswahl->getAuswahl() )
-	{
-		teamS = stAuswahl->zEintragText( stAuswahl->getAuswahl() )->istGleich( "Teams" );
-		stAuswahl->einklappen();
-	}
-	ausw = grAuswahl->getAuswahl();
-	grAuswahl->doPublicMausEreignis( me );
-	if( ausw != grAuswahl->getAuswahl() )
-	{
-		if( grAuswahl->zEintragText( grAuswahl->getAuswahl() )->istGleich( "Gesamt" ) )
-			rundeAusw = -1;
-		Text *nummer = grAuswahl->zEintragText( grAuswahl->getAuswahl() )->getTeilText( 6 );
-		rundeAusw = (int)( *nummer ) - 1;
-		nummer->release();
-		grAuswahl->einklappen();
-	}
-	if( rundeAusw == -1 )
-	{ // Statistik vom gesamtem Spiel
-		if( teamS )
-		{ // Team Statistik
-			int ausw = sortAuswahlGT->getAuswahl();
-			sortAuswahlGT->doPublicMausEreignis( me );
-			if( ausw != sortAuswahlGT->getAuswahl() )
-			{ // Sortierungs Spalte ändert sich
-				tabelleLehren( gesamtTeam, 0 );
-				tabelleFüllen( gesamtTeam );
-				sortAuswahlGT->einklappen();
-			}
-			ausw = sortRichtungGT->getAuswahl();
-			sortRichtungGT->doPublicMausEreignis( me );
-			if( ausw != sortRichtungGT->getAuswahl() )
-			{ // Sortierungs Richtung ändert sich
-				tabelleLehren( gesamtTeam, 0 );
-				tabelleFüllen( gesamtTeam );
-				sortRichtungGT->einklappen();
-			}
-			gesamtTeam->doPublicMausEreignis( me );
-		}
-		else
-		{ // Spieler Statistik
-			int ausw = sortAuswahlGS->getAuswahl();
-			sortAuswahlGS->doPublicMausEreignis( me );
-			if( ausw != sortAuswahlGS->getAuswahl() )
-			{ // Sortierungs Spalte ändert sich
-				tabelleLehren( gesamtSpieler, 0 );
-				tabelleFüllen( gesamtSpieler );
-				sortAuswahlGS->einklappen();
-			}
-			ausw = sortRichtungGS->getAuswahl();
-			sortRichtungGS->doPublicMausEreignis( me );
-			if( ausw != sortRichtungGS->getAuswahl() )
-			{ // Sortierungs Richtung ändert sich
-				tabelleLehren( gesamtSpieler, 0 );
-				tabelleFüllen( gesamtSpieler );
-				sortRichtungGS->einklappen();
-			}
-			gesamtSpieler->doPublicMausEreignis( me );
-		}
-	}
-	else
-	{ // Statistik von einer Runde
-		if( teamS )
-		{ // Team Statistik
-			if( sortAuswahlRT->z( rundeAusw ) )
-			{
-				int ausw = sortAuswahlRT->z( rundeAusw )->getAuswahl();
-				sortAuswahlRT->z( rundeAusw )->doPublicMausEreignis( me );
-				if( ausw != sortAuswahlRT->z( rundeAusw )->getAuswahl() && rundeTeam->z( rundeAusw ) )
-				{ // Sortierungs Spalte ändert sich
-					tabelleLehren( rundeTeam->z( rundeAusw ), 0 );
-					tabelleFüllen( rundeTeam->z( rundeAusw ) );
-					sortAuswahlRT->z( rundeAusw )->einklappen();
-				}
-			}
-			if( sortRichtungRT->z( rundeAusw ) )
-			{
-				int ausw = sortRichtungRT->z( rundeAusw )->getAuswahl();
-				sortRichtungRT->z( rundeAusw )->doPublicMausEreignis( me );
-				if( ausw != sortRichtungRT->z( rundeAusw )->getAuswahl() && rundeTeam->z( rundeAusw ) )
-				{ // Sortierungs Richtung ändert sich
-					tabelleLehren( rundeTeam->z( rundeAusw ), 0 );
-					tabelleFüllen( rundeTeam->z( rundeAusw ) );
-					sortRichtungRT->z( rundeAusw )->einklappen();
-				}
-			}
-			if( rundeTeam->z( rundeAusw ) )
-				rundeTeam->z( rundeAusw )->doPublicMausEreignis( me );
-		}
-		else
-		{ // Spieler Statistik
-			if( sortAuswahlRS->z( rundeAusw ) )
-			{
-				int ausw = sortAuswahlRS->z( rundeAusw )->getAuswahl();
-				sortAuswahlRS->z( rundeAusw )->doPublicMausEreignis( me );
-				if( ausw != sortAuswahlRS->z( rundeAusw )->getAuswahl() && rundeSpieler->z( rundeAusw ) )
-				{ // Sortierungs Spalte ändert sich
-					tabelleLehren( rundeSpieler->z( rundeAusw ), 0 );
-					tabelleFüllen( rundeSpieler->z( rundeAusw ) );
-					sortAuswahlRS->z( rundeAusw )->einklappen();
-				}
-			}
-			if( sortRichtungRS->z( rundeAusw ) )
-			{
-				int ausw = sortRichtungRS->z( rundeAusw )->getAuswahl();
-				sortRichtungRS->z( rundeAusw )->doPublicMausEreignis( me );
-				if( ausw != sortRichtungRS->z( rundeAusw )->getAuswahl() && rundeSpieler->z( rundeAusw ) )
-				{ // Sortierungs Richtung ändert sich
-					tabelleLehren( rundeSpieler->z( rundeAusw ), 0 );
-					tabelleFüllen( rundeSpieler->z( rundeAusw ) );
-					sortRichtungRS->z( rundeAusw )->einklappen();
-				}
-			}
-			if( rundeSpieler->z( rundeAusw ) )
-				rundeSpieler->z( rundeAusw )->doPublicMausEreignis( me );
-		}
-	}
+    // Auswahl Boxen
+    int ausw = stAuswahl->getAuswahl();
+    stAuswahl->doPublicMausEreignis( me );
+    if( ausw != stAuswahl->getAuswahl() )
+    {
+        teamS = stAuswahl->zEintragText( stAuswahl->getAuswahl() )->istGleich( "Teams" );
+        stAuswahl->einklappen();
+    }
+    ausw = grAuswahl->getAuswahl();
+    grAuswahl->doPublicMausEreignis( me );
+    if( ausw != grAuswahl->getAuswahl() )
+    {
+        if( grAuswahl->zEintragText( grAuswahl->getAuswahl() )->istGleich( "Gesamt" ) )
+            rundeAusw = -1;
+        Text *nummer = grAuswahl->zEintragText( grAuswahl->getAuswahl() )->getTeilText( 6 );
+        rundeAusw = (int)( *nummer ) - 1;
+        nummer->release();
+        grAuswahl->einklappen();
+    }
+    if( rundeAusw == -1 )
+    { // Statistik vom gesamtem Spiel
+        if( teamS )
+        { // Team Statistik
+            int ausw = sortAuswahlGT->getAuswahl();
+            sortAuswahlGT->doPublicMausEreignis( me );
+            if( ausw != sortAuswahlGT->getAuswahl() )
+            { // Sortierungs Spalte ändert sich
+                tabelleLehren( gesamtTeam, 0 );
+                tabelleFüllen( gesamtTeam );
+                sortAuswahlGT->einklappen();
+            }
+            ausw = sortRichtungGT->getAuswahl();
+            sortRichtungGT->doPublicMausEreignis( me );
+            if( ausw != sortRichtungGT->getAuswahl() )
+            { // Sortierungs Richtung ändert sich
+                tabelleLehren( gesamtTeam, 0 );
+                tabelleFüllen( gesamtTeam );
+                sortRichtungGT->einklappen();
+            }
+            gesamtTeam->doPublicMausEreignis( me );
+        }
+        else
+        { // Spieler Statistik
+            int ausw = sortAuswahlGS->getAuswahl();
+            sortAuswahlGS->doPublicMausEreignis( me );
+            if( ausw != sortAuswahlGS->getAuswahl() )
+            { // Sortierungs Spalte ändert sich
+                tabelleLehren( gesamtSpieler, 0 );
+                tabelleFüllen( gesamtSpieler );
+                sortAuswahlGS->einklappen();
+            }
+            ausw = sortRichtungGS->getAuswahl();
+            sortRichtungGS->doPublicMausEreignis( me );
+            if( ausw != sortRichtungGS->getAuswahl() )
+            { // Sortierungs Richtung ändert sich
+                tabelleLehren( gesamtSpieler, 0 );
+                tabelleFüllen( gesamtSpieler );
+                sortRichtungGS->einklappen();
+            }
+            gesamtSpieler->doPublicMausEreignis( me );
+        }
+    }
+    else
+    { // Statistik von einer Runde
+        if( teamS )
+        { // Team Statistik
+            if( sortAuswahlRT->z( rundeAusw ) )
+            {
+                int ausw = sortAuswahlRT->z( rundeAusw )->getAuswahl();
+                sortAuswahlRT->z( rundeAusw )->doPublicMausEreignis( me );
+                if( ausw != sortAuswahlRT->z( rundeAusw )->getAuswahl() && rundeTeam->z( rundeAusw ) )
+                { // Sortierungs Spalte ändert sich
+                    tabelleLehren( rundeTeam->z( rundeAusw ), 0 );
+                    tabelleFüllen( rundeTeam->z( rundeAusw ) );
+                    sortAuswahlRT->z( rundeAusw )->einklappen();
+                }
+            }
+            if( sortRichtungRT->z( rundeAusw ) )
+            {
+                int ausw = sortRichtungRT->z( rundeAusw )->getAuswahl();
+                sortRichtungRT->z( rundeAusw )->doPublicMausEreignis( me );
+                if( ausw != sortRichtungRT->z( rundeAusw )->getAuswahl() && rundeTeam->z( rundeAusw ) )
+                { // Sortierungs Richtung ändert sich
+                    tabelleLehren( rundeTeam->z( rundeAusw ), 0 );
+                    tabelleFüllen( rundeTeam->z( rundeAusw ) );
+                    sortRichtungRT->z( rundeAusw )->einklappen();
+                }
+            }
+            if( rundeTeam->z( rundeAusw ) )
+                rundeTeam->z( rundeAusw )->doPublicMausEreignis( me );
+        }
+        else
+        { // Spieler Statistik
+            if( sortAuswahlRS->z( rundeAusw ) )
+            {
+                int ausw = sortAuswahlRS->z( rundeAusw )->getAuswahl();
+                sortAuswahlRS->z( rundeAusw )->doPublicMausEreignis( me );
+                if( ausw != sortAuswahlRS->z( rundeAusw )->getAuswahl() && rundeSpieler->z( rundeAusw ) )
+                { // Sortierungs Spalte ändert sich
+                    tabelleLehren( rundeSpieler->z( rundeAusw ), 0 );
+                    tabelleFüllen( rundeSpieler->z( rundeAusw ) );
+                    sortAuswahlRS->z( rundeAusw )->einklappen();
+                }
+            }
+            if( sortRichtungRS->z( rundeAusw ) )
+            {
+                int ausw = sortRichtungRS->z( rundeAusw )->getAuswahl();
+                sortRichtungRS->z( rundeAusw )->doPublicMausEreignis( me );
+                if( ausw != sortRichtungRS->z( rundeAusw )->getAuswahl() && rundeSpieler->z( rundeAusw ) )
+                { // Sortierungs Richtung ändert sich
+                    tabelleLehren( rundeSpieler->z( rundeAusw ), 0 );
+                    tabelleFüllen( rundeSpieler->z( rundeAusw ) );
+                    sortRichtungRS->z( rundeAusw )->einklappen();
+                }
+            }
+            if( rundeSpieler->z( rundeAusw ) )
+                rundeSpieler->z( rundeAusw )->doPublicMausEreignis( me );
+        }
+    }
 }
 
 bool StatistikTabelle::tick( double tickVal )
 {
-	if( rundeAusw == -1 )
-	{ // Statistik vom gesamtem Spiel
-		if( teamS )
-		{ // Team Statistik
-			rend |= gesamtTeam->tick( tickVal );
-			rend |= sortAuswahlGT->tick( tickVal );
-			rend |= sortRichtungGT->tick( tickVal );
-		}
-		else
-		{ // Spieler Statistik
-			rend |= gesamtSpieler->tick( tickVal );
-			rend |= sortAuswahlGS->tick( tickVal );
-			rend |= sortRichtungGS->tick( tickVal );
-		}
-	}
-	else
-	{ // Statistik von einer Runde
-		if( teamS )
-		{ // Team Statistik
-			if( rundeTeam->z( rundeAusw ) )
-				rend |= rundeTeam->z( rundeAusw )->tick( tickVal );
-			if( sortAuswahlRT->z( rundeAusw ) )
-				rend |= sortAuswahlRT->z( rundeAusw )->tick( tickVal );
-			if( sortRichtungRT->z( rundeAusw ) )
-				rend |= sortRichtungRT->z( rundeAusw )->tick( tickVal );
-		}
-		else
-		{ // Spieler Statistik
-			if( rundeSpieler->z( rundeAusw ) )
-				rend |= rundeSpieler->z( rundeAusw )->tick( tickVal );
-			if( sortAuswahlRS->z( rundeAusw ) )
-				rend |= sortAuswahlRS->z( rundeAusw )->tick( tickVal );
-			if( sortRichtungRS->z( rundeAusw ) )
-				rend |= sortRichtungRS->z( rundeAusw )->tick( tickVal );
-		}
-	}
-	// Auswahl Boxen
-	rend |= stAuswahl->tick( tickVal );
-	rend |= grAuswahl->tick( tickVal );
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    if( rundeAusw == -1 )
+    { // Statistik vom gesamtem Spiel
+        if( teamS )
+        { // Team Statistik
+            rend |= gesamtTeam->tick( tickVal );
+            rend |= sortAuswahlGT->tick( tickVal );
+            rend |= sortRichtungGT->tick( tickVal );
+        }
+        else
+        { // Spieler Statistik
+            rend |= gesamtSpieler->tick( tickVal );
+            rend |= sortAuswahlGS->tick( tickVal );
+            rend |= sortRichtungGS->tick( tickVal );
+        }
+    }
+    else
+    { // Statistik von einer Runde
+        if( teamS )
+        { // Team Statistik
+            if( rundeTeam->z( rundeAusw ) )
+                rend |= rundeTeam->z( rundeAusw )->tick( tickVal );
+            if( sortAuswahlRT->z( rundeAusw ) )
+                rend |= sortAuswahlRT->z( rundeAusw )->tick( tickVal );
+            if( sortRichtungRT->z( rundeAusw ) )
+                rend |= sortRichtungRT->z( rundeAusw )->tick( tickVal );
+        }
+        else
+        { // Spieler Statistik
+            if( rundeSpieler->z( rundeAusw ) )
+                rend |= rundeSpieler->z( rundeAusw )->tick( tickVal );
+            if( sortAuswahlRS->z( rundeAusw ) )
+                rend |= sortAuswahlRS->z( rundeAusw )->tick( tickVal );
+            if( sortRichtungRS->z( rundeAusw ) )
+                rend |= sortRichtungRS->z( rundeAusw )->tick( tickVal );
+        }
+    }
+    // Auswahl Boxen
+    rend |= stAuswahl->tick( tickVal );
+    rend |= grAuswahl->tick( tickVal );
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void StatistikTabelle::render( Bild &zRObj )
 {
-	if( rundeAusw == -1 )
-	{ // Statistik vom gesamtem Spiel
-		if( teamS )
-		{ // Team Statistik
-			gesamtTeam->render( zRObj );
-			sortAuswahlGT->render( zRObj );
-			sortRichtungGT->render( zRObj );
-		}
-		else
-		{ // Spieler Statistik
-			gesamtSpieler->render( zRObj );
-			sortAuswahlGS->render( zRObj );
-			sortRichtungGS->render( zRObj );
-		}
-	}
-	else
-	{ // Statistik von einer Runde
-		if( teamS )
-		{ // Team Statistik
-			if( rundeTeam->z( rundeAusw ) )
-				rundeTeam->z( rundeAusw )->render( zRObj );
-			if( sortAuswahlRT->z( rundeAusw ) )
-				sortAuswahlRT->z( rundeAusw )->render( zRObj );
-			if( sortRichtungRT->z( rundeAusw ) )
-				sortRichtungRT->z( rundeAusw )->render( zRObj );
-		}
-		else
-		{ // Spieler Statistik
-			if( rundeSpieler->z( rundeAusw ) )
-				rundeSpieler->z( rundeAusw )->render( zRObj );
-			if( sortAuswahlRS->z( rundeAusw ) )
-				sortAuswahlRS->z( rundeAusw )->render( zRObj );
-			if( sortRichtungRS->z( rundeAusw ) )
-				sortRichtungRS->z( rundeAusw )->render( zRObj );
-		}
-	}
-	// Auswahl Boxen
-	stAuswahl->render( zRObj );
-	grAuswahl->render( zRObj );
+    if( rundeAusw == -1 )
+    { // Statistik vom gesamtem Spiel
+        if( teamS )
+        { // Team Statistik
+            gesamtTeam->render( zRObj );
+            sortAuswahlGT->render( zRObj );
+            sortRichtungGT->render( zRObj );
+        }
+        else
+        { // Spieler Statistik
+            gesamtSpieler->render( zRObj );
+            sortAuswahlGS->render( zRObj );
+            sortRichtungGS->render( zRObj );
+        }
+    }
+    else
+    { // Statistik von einer Runde
+        if( teamS )
+        { // Team Statistik
+            if( rundeTeam->z( rundeAusw ) )
+                rundeTeam->z( rundeAusw )->render( zRObj );
+            if( sortAuswahlRT->z( rundeAusw ) )
+                sortAuswahlRT->z( rundeAusw )->render( zRObj );
+            if( sortRichtungRT->z( rundeAusw ) )
+                sortRichtungRT->z( rundeAusw )->render( zRObj );
+        }
+        else
+        { // Spieler Statistik
+            if( rundeSpieler->z( rundeAusw ) )
+                rundeSpieler->z( rundeAusw )->render( zRObj );
+            if( sortAuswahlRS->z( rundeAusw ) )
+                sortAuswahlRS->z( rundeAusw )->render( zRObj );
+            if( sortRichtungRS->z( rundeAusw ) )
+                sortRichtungRS->z( rundeAusw )->render( zRObj );
+        }
+    }
+    // Auswahl Boxen
+    stAuswahl->render( zRObj );
+    grAuswahl->render( zRObj );
 }
 
 // constant
 int StatistikTabelle::getRunde() const
 {
-	return rundeAusw;
+    return rundeAusw;
 }
 
 // Reference Counting
 StatistikTabelle *StatistikTabelle::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 StatistikTabelle *StatistikTabelle::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }