framework changes

Asteroids/Editor/Interface/Dialogs/Nachricht.cpp

@@ -12,37 +12,37 @@
 //  tr: Die zu verwendende Schrift
 //  nachricht: Der Fehler, der angezeigt werden soll
 //  maxSize: Die Bildschirmgröße in Pixeln
-Nachricht::Nachricht( TextRenderer *tr, UIInit &uiFactory, char *nachricht, Punkt maxSize, std::function< void() > onClose )
-    : Dialog( tr )
+Nachricht::Nachricht(TextRenderer* tr, UIInit& uiFactory, const char* nachricht, Punkt maxSize, std::function< void() > onClose)
+	: Dialog(tr)
 {
-    Text *tmp = new Text( nachricht );
-    tr->setSchriftSize( 12 );
-    tr->textFormatieren( tmp, 300 );
-    int br = tr->getTextBreite( tmp->getText() );
-    int hö = tr->getTextHeight( tmp->getText() );
-    setSize( br + 12, hö + 63 );
-    setPosition( maxSize / 2 - getSize() / 2 );
+	Text* tmp = new Text(nachricht);
+	tr->setSchriftSize(12);
+	tr->textFormatieren(tmp, 300);
+	int br = tr->getTextBreite(tmp->getText());
+	int hö = tr->getTextHeight(tmp->getText());
+	setSize(br + 12, hö + 63);
+	setPosition(maxSize / 2 - getSize() / 2);
 
-    TextFeld *text = initTextFeld( 5, 5, br, hö, uiFactory, TextFeld::Style::Text, tmp->getText() );
-    addMember( text );
-    tmp->release();
-    Knopf *ok = initKnopf( br - 94, hö + 12, 100, 20, uiFactory, Knopf::Style::Normal, "Ok" );
-    addMember( ok );
-    bool *verl = &verlassen;
+	TextFeld* text = initTextFeld(5, 5, br, hö, uiFactory, TextFeld::Style::Text, tmp->getText());
+	addMember(text);
+	tmp->release();
+	Knopf* ok = initKnopf(br - 94, hö + 12, 100, 20, uiFactory, Knopf::Style::Normal, "Ok");
+	addMember(ok);
+	bool* verl = &verlassen;
 
-    auto me = [verl, onClose]( void *param, void *obj, MausEreignis me ) -> bool
-    {
-        if( me.id == ME_RLinks && !me.verarbeitet )
-        {
-            *verl = 1;
-            if( onClose )
-                onClose();
-        }
-        return 1;
-    };
+	auto me = [verl, onClose](void* param, void* obj, MausEreignis me) -> bool
+	{
+		if (me.id == ME_RLinks && !me.verarbeitet)
+		{
+			*verl = 1;
+			if (onClose)
+				onClose();
+		}
+		return 1;
+	};
 
-    ok->setMausEreignis( me );
-    setClosingMe( me );
+	ok->setMausEreignis(me);
+	setClosingMe(me);
 }
 
 // Destruktor

Asteroids/Editor/Interface/Dialogs/Nachricht.h

@@ -8,11 +8,11 @@ using namespace Framework;
 class Nachricht : public Dialog
 {
 public:
-    // Konstruktor
-    //  tr: Die zu verwendende Schrift
-    //  nachricht: Der Fehler, der angezeigt werden soll
-    //  maxSize: Die Bildschirmgröße in Pixeln
-    Nachricht( TextRenderer *tr, UIInit &uiFactory, char *nachricht, Punkt maxSize, std::function< void() > onClose );
-    // Destruktor
-    ~Nachricht();
+	// Konstruktor
+	//  tr: Die zu verwendende Schrift
+	//  nachricht: Der Fehler, der angezeigt werden soll
+	//  maxSize: Die Bildschirmgröße in Pixeln
+	Nachricht(TextRenderer* tr, UIInit& uiFactory, const char* nachricht, Punkt maxSize, std::function< void() > onClose);
+	// Destruktor
+	~Nachricht();
 };

Asteroids/Editor/Interface/RightTools/ObjektOptionen/ObjektOptionen.cpp

@@ -4,460 +4,460 @@
 
 using namespace Editor;
 
-ObjektTool::ObjektTool( UIInit &uiFactory, KarteDaten *daten )
-    : RightTool()
+ObjektTool::ObjektTool(UIInit& uiFactory, KarteDaten* daten)
+	: RightTool()
 {
-    dialog = 0;
-    dialog2 = 0;
-    this->uiFactory = uiFactory;
-    this->daten = daten;
-    objekte = uiFactory.createAuswahlListe( uiFactory.initParam );
-    objekte->setStyle( ( AuswahlListe::Style::Normal & ~AuswahlListe::Style::FeldHAlpha ) | AuswahlBox::Style::VScroll );
-    objekte->setSize( 290, 200 );
-    objekte->setVertikalKlickScroll( 1 );
-    int anz = daten->getObjektAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        const ObjektDaten *o = daten->getObjekt( i );
-        objekte->addEintrag( Text( o->id ) );
-    }
-    neuesObjekt = initKnopf( 0, 205, 290, 20, uiFactory, Knopf::Style::Normal, "Neues Objekt erstellen" );
-    neuesObjekt->setMausEreignis( [this, &uiFactory]( void *p, void *o, MausEreignis me )
-    {
-        if( me.id == ME_RLinks )
-        {
-            cs.lock();
-            if( dialog )
-                dialog->release();
-            dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this, &uiFactory]( const char *modelPath )
-            {
-                if( !modelPath )
-                    return;
-                cs.lock();
-                if( dialog2 )
-                    dialog2->release();
-                dialog2 = dialog;
-                dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this, modelPath]( const char *texturPath )
-                {
-                    if( !texturPath )
-                        return;
-                    this->daten->getResourceIdFromPath( modelPath, [this, texturPath]( int modelId )
-                    {
-                        this->daten->getResourceIdFromPath( texturPath, [this, modelId]( int texturId )
-                        {
-                            ObjektDaten o = ObjektDaten();
-                            o.m2d = modelId;
-                            o.bild = texturId;
-                            o.scale = 1;
-                            o.maxStabilität = 100;
-                            o.maxEnergie = 100;
-                            o.energieRadius = 0;
-                            o.reparatur = 0;
-                            o.akkuLeistung = 0;
-                            o.team = this->daten->getTeam( 0 )->id;
-                            o.pos.x = 0;
-                            o.pos.y = 0;
-                            o.rot = 0;
-                            o.style = 0;
-                            this->daten->addObjekt( o, [this]( int id )
-                            {
-                                objekte->addEintrag( Text( id ) );
-                                selectObject( id );
-                            } );
-                        } );
-                    } );
-                }, screenSize );
-                cs.unlock();
-            }, screenSize );
-            cs.unlock();
-        }
-        return 1;
-    } );
-    model = new M2DVorschau();
-    model->setStyle( M2DVorschau::Style::Rahmen | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrScale | M2DVorschau::Style::Erlaubt );
-    model->setSize( 290, 290 );
-    model->setPosition( 0, 230 );
-    changeModel = initKnopf( 0, 520, 142, 20, uiFactory, Knopf::Style::Normal, "Model ändern" );
-    changeModel->setMausEreignis( [this, &uiFactory]( void *p, void *o, MausEreignis me )
-    {
-        if( me.id == ME_RLinks )
-        {
-            cs.lock();
-            if( dialog )
-                dialog->release();
-            dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this]( const char *path )
-            {
-                if( !path )
-                    return;
-                modelPath = path;
-                Model2DData *data = this->daten->loadModelFromPath( modelPath );
-                Textur2D *textur = new Textur2D();
-                textur->setTexturZ( this->daten->loadBildFromPath( texturPath ) );
-                model->postAction( [this, data, textur]()
-                {
-                    model->setModel2D( data );
-                    model->zModel()->setTextur( textur );
-                } );
-            }, screenSize );
-            cs.unlock();
-        }
-        return 1;
-    } );
-    changeTextur = initKnopf( 147, 520, 143, 20, uiFactory, Knopf::Style::Normal, "Textur ändern" );
-    changeTextur->setMausEreignis( [this, &uiFactory]( void *p, void *o, MausEreignis me )
-    {
-        if( me.id == ME_RLinks )
-        {
-            cs.lock();
-            if( dialog )
-                dialog->release();
-            dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this]( const char *path )
-            {
-                if( !path )
-                    return;
-                texturPath = path;
-                Textur2D *textur = new Textur2D();
-                textur->setTexturZ( this->daten->loadBildFromPath( texturPath ) );
-                model->postAction( [this, textur]()
-                {
-                    model->zModel()->setTextur( textur );
-                } );
-            }, screenSize );
-            cs.unlock();
-        }
-        return 1;
-    } );
-    stabilitätT = initTextFeld( 0, 545, 100, 20, uiFactory, TextFeld::Style::Text, "Stabilität: " );
-    stabilität = initTextFeld( 100, 545, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    energieT = initTextFeld( 0, 570, 100, 20, uiFactory, TextFeld::Style::Text, "Energie: " );
-    energie = initTextFeld( 100, 570, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    energieRadiusT = initTextFeld( 0, 595, 100, 20, uiFactory, TextFeld::Style::Text, "Radius: " );
-    energieRadius = initTextFeld( 100, 595, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    reparaturT = initTextFeld( 0, 620, 100, 20, uiFactory, TextFeld::Style::Text, "Reparatur: " );
-    reparatur = initTextFeld( 100, 620, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    akkuLeistungT = initTextFeld( 0, 645, 100, 20, uiFactory, TextFeld::Style::Text, "Akku: " );
-    akkuLeistung = initTextFeld( 100, 645, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    team = initAuswahlBox( 0, 670, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
-    anz = daten->getTeamAnzahl();
-    for( int i = 0; i < anz; i++ )
-        team->addEintrag( daten->getTeamName( i ) );
-    verwundbar = initKontrollKnopf( 0, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Verwundbar" );
-    beweglich = initKontrollKnopf( 150, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Beweglich" );
-    collision = initKontrollKnopf( 0, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Kollision" );
-    laserCollision = initKontrollKnopf( 150, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Laser Kollision" );
-    neutral = initKontrollKnopf( 0, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Neutral" );
-    erfahrung = initKontrollKnopf( 150, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Treffer Erfahrung" );
-    lebensAnzeige = initKontrollKnopf( 0, 770, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Lebensanzeige" );
-    speichern = initKnopf( 0, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern" );
-    speichern->setMausEreignis( [this]( void *p, void *o, MausEreignis me )
-    {
-        if( me.id == ME_RLinks )
-        {
-            ObjektDaten *o = this->daten->getObjekt( this->daten->getObjektIndexById( *objekte->zEintrag( objekte->getAuswahl() )->zText() ) );
-            this->daten->getResourceIdFromPath( modelPath, [this, o]( int id )
-            {
-                o->m2d = id;
-                this->daten->getResourceIdFromPath( texturPath, [this, o]( int id )
-                {
-                    o->bild = id;
-                    o->maxStabilität = *stabilität->zText();
-                    o->maxEnergie = *energie->zText();
-                    o->energieRadius = *energieRadius->zText();
-                    o->reparatur = *reparatur->zText();
-                    o->akkuLeistung = *akkuLeistung->zText();
-                    o->team = team->getAuswahl();
-                    o->style = 0;
-                    if( verwundbar->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x1;
-                    if( beweglich->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x2;
-                    if( collision->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x4;
-                    if( laserCollision->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x8;
-                    if( neutral->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x10;
-                    if( erfahrung->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x20;
-                    if( lebensAnzeige->hatStyle( KontrollKnopf::Style::Selected ) )
-                        o->style |= 0x40;
-                    o->update();
-                } );
-            } );
-        }
-        return 1;
-    } );
-    löschen = initKnopf( 105, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Löschen" );
-    löschen->setMausEreignis( [this]( void *p, void *o, MausEreignis me )
-    {
-        if( me.id == ME_RLinks )
-        {
-            int ausw = objekte->getAuswahl();
-            this->daten->removeObjekt( this->daten->getObjektIndexById( *objekte->zEintrag( objekte->getAuswahl() )->zText() ) );
-            selectObject( 0 );
-            objekte->removeEintrag( ausw );
-        }
-        return 1;
-    } );
-    selectObject( 0 );
+	dialog = 0;
+	dialog2 = 0;
+	this->uiFactory = uiFactory;
+	this->daten = daten;
+	objekte = uiFactory.createAuswahlListe(uiFactory.initParam);
+	objekte->setStyle((AuswahlListe::Style::Normal & ~AuswahlListe::Style::FeldHAlpha) | AuswahlBox::Style::VScroll);
+	objekte->setSize(290, 200);
+	objekte->setVertikalKlickScroll(1);
+	int anz = daten->getObjektAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		const ObjektDaten* o = daten->getObjekt(i);
+		objekte->addEintrag(Text(o->id));
+	}
+	neuesObjekt = initKnopf(0, 205, 290, 20, uiFactory, Knopf::Style::Normal, "Neues Objekt erstellen");
+	neuesObjekt->setMausEreignis([this, &uiFactory](void* p, void* o, MausEreignis me)
+		{
+			if (me.id == ME_RLinks)
+			{
+				cs.lock();
+				if (dialog)
+					dialog->release();
+				dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this, &uiFactory](const char* modelPath)
+					{
+						if (!modelPath)
+							return;
+						cs.lock();
+						if (dialog2)
+							dialog2->release();
+						dialog2 = dialog;
+						dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this, modelPath](const char* texturPath)
+							{
+								if (!texturPath)
+									return;
+								this->daten->getResourceIdFromPath(modelPath, [this, texturPath](int modelId)
+									{
+										this->daten->getResourceIdFromPath(texturPath, [this, modelId](int texturId)
+											{
+												ObjektDaten o = ObjektDaten();
+												o.m2d = modelId;
+												o.bild = texturId;
+												o.scale = 1;
+												o.maxStabilität = 100;
+												o.maxEnergie = 100;
+												o.energieRadius = 0;
+												o.reparatur = 0;
+												o.akkuLeistung = 0;
+												o.team = this->daten->getTeam(0)->id;
+												o.pos.x = 0;
+												o.pos.y = 0;
+												o.rot = 0;
+												o.style = 0;
+												this->daten->addObjekt(o, [this](int id)
+													{
+														objekte->addEintrag(Text(id));
+														selectObject(id);
+													});
+											});
+									});
+							}, screenSize);
+						cs.unlock();
+					}, screenSize);
+				cs.unlock();
+			}
+			return 1;
+		});
+	model = new M2DVorschau();
+	model->setStyle(M2DVorschau::Style::Rahmen | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrScale | M2DVorschau::Style::Erlaubt);
+	model->setSize(290, 290);
+	model->setPosition(0, 230);
+	changeModel = initKnopf(0, 520, 142, 20, uiFactory, Knopf::Style::Normal, "Model ändern");
+	changeModel->setMausEreignis([this, &uiFactory](void* p, void* o, MausEreignis me)
+		{
+			if (me.id == ME_RLinks)
+			{
+				cs.lock();
+				if (dialog)
+					dialog->release();
+				dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this](const char* path)
+					{
+						if (!path)
+							return;
+						modelPath = path;
+						Model2DData* data = this->daten->loadModelFromPath(modelPath);
+						Textur2D* textur = new Textur2D();
+						textur->setTexturZ(this->daten->loadBildFromPath(texturPath));
+						model->postAction([this, data, textur]()
+							{
+								model->setModel2D(data);
+								model->zModel()->setTextur(textur);
+							});
+					}, screenSize);
+				cs.unlock();
+			}
+			return 1;
+		});
+	changeTextur = initKnopf(147, 520, 143, 20, uiFactory, Knopf::Style::Normal, "Textur ändern");
+	changeTextur->setMausEreignis([this, &uiFactory](void* p, void* o, MausEreignis me)
+		{
+			if (me.id == ME_RLinks)
+			{
+				cs.lock();
+				if (dialog)
+					dialog->release();
+				dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this](const char* path)
+					{
+						if (!path)
+							return;
+						texturPath = path;
+						Textur2D* textur = new Textur2D();
+						textur->setTexturZ(this->daten->loadBildFromPath(texturPath));
+						model->postAction([this, textur]()
+							{
+								model->zModel()->setTextur(textur);
+							});
+					}, screenSize);
+				cs.unlock();
+			}
+			return 1;
+		});
+	stabilitätT = initTextFeld(0, 545, 100, 20, uiFactory, TextFeld::Style::Text, "Stabilität: ");
+	stabilität = initTextFeld(100, 545, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	energieT = initTextFeld(0, 570, 100, 20, uiFactory, TextFeld::Style::Text, "Energie: ");
+	energie = initTextFeld(100, 570, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	energieRadiusT = initTextFeld(0, 595, 100, 20, uiFactory, TextFeld::Style::Text, "Radius: ");
+	energieRadius = initTextFeld(100, 595, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	reparaturT = initTextFeld(0, 620, 100, 20, uiFactory, TextFeld::Style::Text, "Reparatur: ");
+	reparatur = initTextFeld(100, 620, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	akkuLeistungT = initTextFeld(0, 645, 100, 20, uiFactory, TextFeld::Style::Text, "Akku: ");
+	akkuLeistung = initTextFeld(100, 645, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	team = initAuswahlBox(0, 670, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {});
+	anz = daten->getTeamAnzahl();
+	for (int i = 0; i < anz; i++)
+		team->addEintrag(daten->getTeamName(i));
+	verwundbar = initKontrollKnopf(0, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Verwundbar");
+	beweglich = initKontrollKnopf(150, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Beweglich");
+	collision = initKontrollKnopf(0, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Kollision");
+	laserCollision = initKontrollKnopf(150, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Laser Kollision");
+	neutral = initKontrollKnopf(0, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Neutral");
+	erfahrung = initKontrollKnopf(150, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Treffer Erfahrung");
+	lebensAnzeige = initKontrollKnopf(0, 770, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Lebensanzeige");
+	speichern = initKnopf(0, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern");
+	speichern->setMausEreignis([this](void* p, void* o, MausEreignis me)
+		{
+			if (me.id == ME_RLinks)
+			{
+				ObjektDaten* o = this->daten->getObjekt(this->daten->getObjektIndexById((int)*objekte->zEintrag(objekte->getAuswahl())->zText()));
+				this->daten->getResourceIdFromPath(modelPath, [this, o](int id)
+					{
+						o->m2d = id;
+						this->daten->getResourceIdFromPath(texturPath, [this, o](int id)
+							{
+								o->bild = id;
+								o->maxStabilität = (int)*stabilität->zText();
+								o->maxEnergie = (int)*energie->zText();
+								o->energieRadius = (int)*energieRadius->zText();
+								o->reparatur = (double)*reparatur->zText();
+								o->akkuLeistung = (double)*akkuLeistung->zText();
+								o->team = team->getAuswahl();
+								o->style = 0;
+								if (verwundbar->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x1;
+								if (beweglich->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x2;
+								if (collision->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x4;
+								if (laserCollision->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x8;
+								if (neutral->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x10;
+								if (erfahrung->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x20;
+								if (lebensAnzeige->hatStyle(KontrollKnopf::Style::Selected))
+									o->style |= 0x40;
+								o->update();
+							});
+					});
+			}
+			return 1;
+		});
+	löschen = initKnopf(105, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Löschen");
+	löschen->setMausEreignis([this](void* p, void* o, MausEreignis me)
+		{
+			if (me.id == ME_RLinks)
+			{
+				int ausw = objekte->getAuswahl();
+				this->daten->removeObjekt(this->daten->getObjektIndexById((int)*objekte->zEintrag(objekte->getAuswahl())->zText()));
+				selectObject(0);
+				objekte->removeEintrag(ausw);
+			}
+			return 1;
+		});
+	selectObject(0);
 }
 
 ObjektTool::~ObjektTool()
 {
-    cs.lock();
-    if( dialog )
-        dialog->release();
-    if( dialog2 )
-        dialog2->release();
-    cs.unlock();
-    objekte->release();
-    neuesObjekt->release();
-    model->release();
-    changeModel->release();
-    changeTextur->release();
-    stabilitätT->release();
-    stabilität->release();
-    energieT->release();
-    energie->release();
-    energieRadiusT->release();
-    energieRadius->release();
-    reparaturT->release();
-    reparatur->release();
-    akkuLeistungT->release();
-    akkuLeistung->release();
-    team->release();
-    verwundbar->release();
-    beweglich->release();
-    collision->release();
-    laserCollision->release();
-    neutral->release();
-    erfahrung->release();
-    lebensAnzeige->release();
-    speichern->release();
-    löschen->release();
-    daten->release();
+	cs.lock();
+	if (dialog)
+		dialog->release();
+	if (dialog2)
+		dialog2->release();
+	cs.unlock();
+	objekte->release();
+	neuesObjekt->release();
+	model->release();
+	changeModel->release();
+	changeTextur->release();
+	stabilitätT->release();
+	stabilität->release();
+	energieT->release();
+	energie->release();
+	energieRadiusT->release();
+	energieRadius->release();
+	reparaturT->release();
+	reparatur->release();
+	akkuLeistungT->release();
+	akkuLeistung->release();
+	team->release();
+	verwundbar->release();
+	beweglich->release();
+	collision->release();
+	laserCollision->release();
+	neutral->release();
+	erfahrung->release();
+	lebensAnzeige->release();
+	speichern->release();
+	löschen->release();
+	daten->release();
 }
 
-void ObjektTool::doPublicMausEreignis( MausEreignis &me )
+void ObjektTool::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        me.verarbeitet = 1;
-    Punkt tmpM( me.mx, me.my );
-    me.mx = me.mx + screenSize.x - 300;
-    me.my = me.my;
-    cs.lock();
-    if( dialog )
-        dialog->doPublicMausEreignis( me );
-    cs.unlock();
-    me.mx = tmpM.x;
-    me.my = tmpM.y;
-    me.mx -= pos.x;
-    me.my -= pos.y;
-    team->doPublicMausEreignis( me );
-    int ausw = objekte->getAuswahl();
-    objekte->doPublicMausEreignis( me );
-    if( objekte->getAuswahl() != ausw && objekte->getAuswahl() >= 0 )
-        selectObject( *objekte->zEintrag( objekte->getAuswahl() )->zText() );
-    if( objekte->getAuswahl() != ausw && objekte->getAuswahl() < 0 )
-        selectObject( 0 );
-    neuesObjekt->doPublicMausEreignis( me );
-    model->doPublicMausEreignis( me );
-    changeModel->doPublicMausEreignis( me );
-    changeTextur->doPublicMausEreignis( me );
-    stabilität->doPublicMausEreignis( me );
-    energie->doPublicMausEreignis( me );
-    energieRadius->doPublicMausEreignis( me );
-    reparatur->doPublicMausEreignis( me );
-    akkuLeistung->doPublicMausEreignis( me );
-    verwundbar->doPublicMausEreignis( me );
-    beweglich->doPublicMausEreignis( me );
-    collision->doPublicMausEreignis( me );
-    laserCollision->doPublicMausEreignis( me );
-    neutral->doPublicMausEreignis( me );
-    erfahrung->doPublicMausEreignis( me );
-    lebensAnzeige->doPublicMausEreignis( me );
-    speichern->doPublicMausEreignis( me );
-    löschen->doPublicMausEreignis( me );
-    me.mx += pos.x;
-    me.my += pos.y;
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        me.verarbeitet = vera;
+	bool vera = me.verarbeitet;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		me.verarbeitet = 1;
+	Punkt tmpM(me.mx, me.my);
+	me.mx = me.mx + screenSize.x - 300;
+	me.my = me.my;
+	cs.lock();
+	if (dialog)
+		dialog->doPublicMausEreignis(me);
+	cs.unlock();
+	me.mx = tmpM.x;
+	me.my = tmpM.y;
+	me.mx -= pos.x;
+	me.my -= pos.y;
+	team->doPublicMausEreignis(me);
+	int ausw = objekte->getAuswahl();
+	objekte->doPublicMausEreignis(me);
+	if (objekte->getAuswahl() != ausw && objekte->getAuswahl() >= 0)
+		selectObject((int)*objekte->zEintrag(objekte->getAuswahl())->zText());
+	if (objekte->getAuswahl() != ausw && objekte->getAuswahl() < 0)
+		selectObject(0);
+	neuesObjekt->doPublicMausEreignis(me);
+	model->doPublicMausEreignis(me);
+	changeModel->doPublicMausEreignis(me);
+	changeTextur->doPublicMausEreignis(me);
+	stabilität->doPublicMausEreignis(me);
+	energie->doPublicMausEreignis(me);
+	energieRadius->doPublicMausEreignis(me);
+	reparatur->doPublicMausEreignis(me);
+	akkuLeistung->doPublicMausEreignis(me);
+	verwundbar->doPublicMausEreignis(me);
+	beweglich->doPublicMausEreignis(me);
+	collision->doPublicMausEreignis(me);
+	laserCollision->doPublicMausEreignis(me);
+	neutral->doPublicMausEreignis(me);
+	erfahrung->doPublicMausEreignis(me);
+	lebensAnzeige->doPublicMausEreignis(me);
+	speichern->doPublicMausEreignis(me);
+	löschen->doPublicMausEreignis(me);
+	me.mx += pos.x;
+	me.my += pos.y;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		me.verarbeitet = vera;
 }
 
-void ObjektTool::doTastaturEreignis( TastaturEreignis &te )
+void ObjektTool::doTastaturEreignis(TastaturEreignis& te)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return;
-    cs.lock();
-    if( dialog )
-        dialog->doTastaturEreignis( te );
-    cs.unlock();
-    model->doTastaturEreignis( te );
-    stabilität->doTastaturEreignis( te );
-    energie->doTastaturEreignis( te );
-    energieRadius->doTastaturEreignis( te );
-    reparatur->doTastaturEreignis( te );
-    akkuLeistung->doTastaturEreignis( te );
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return;
+	cs.lock();
+	if (dialog)
+		dialog->doTastaturEreignis(te);
+	cs.unlock();
+	model->doTastaturEreignis(te);
+	stabilität->doTastaturEreignis(te);
+	energie->doTastaturEreignis(te);
+	energieRadius->doTastaturEreignis(te);
+	reparatur->doTastaturEreignis(te);
+	akkuLeistung->doTastaturEreignis(te);
 }
 
-bool ObjektTool::tick( double tickVal )
+bool ObjektTool::tick(double tickVal)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return RightTool::tick( tickVal );
-    cs.lock();
-    if( dialog )
-        rend |= dialog->tick( tickVal );
-    cs.unlock();
-    rend |= objekte->tick( tickVal );
-    rend |= neuesObjekt->tick( tickVal );
-    rend |= model->tick( tickVal );
-    rend |= changeModel->tick( tickVal );
-    rend |= changeTextur->tick( tickVal );
-    rend |= stabilität->tick( tickVal );
-    rend |= energie->tick( tickVal );
-    rend |= energieRadius->tick( tickVal );
-    rend |= reparatur->tick( tickVal );
-    rend |= akkuLeistung->tick( tickVal );
-    rend |= team->tick( tickVal );
-    rend |= verwundbar->tick( tickVal );
-    rend |= beweglich->tick( tickVal );
-    rend |= collision->tick( tickVal );
-    rend |= laserCollision->tick( tickVal );
-    rend |= neutral->tick( tickVal );
-    rend |= erfahrung->tick( tickVal );
-    rend |= lebensAnzeige->tick( tickVal );
-    rend |= speichern->tick( tickVal );
-    rend |= löschen->tick( tickVal );
-    return RightTool::tick( tickVal );
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return RightTool::tick(tickVal);
+	cs.lock();
+	if (dialog)
+		rend |= dialog->tick(tickVal);
+	cs.unlock();
+	rend |= objekte->tick(tickVal);
+	rend |= neuesObjekt->tick(tickVal);
+	rend |= model->tick(tickVal);
+	rend |= changeModel->tick(tickVal);
+	rend |= changeTextur->tick(tickVal);
+	rend |= stabilität->tick(tickVal);
+	rend |= energie->tick(tickVal);
+	rend |= energieRadius->tick(tickVal);
+	rend |= reparatur->tick(tickVal);
+	rend |= akkuLeistung->tick(tickVal);
+	rend |= team->tick(tickVal);
+	rend |= verwundbar->tick(tickVal);
+	rend |= beweglich->tick(tickVal);
+	rend |= collision->tick(tickVal);
+	rend |= laserCollision->tick(tickVal);
+	rend |= neutral->tick(tickVal);
+	rend |= erfahrung->tick(tickVal);
+	rend |= lebensAnzeige->tick(tickVal);
+	rend |= speichern->tick(tickVal);
+	rend |= löschen->tick(tickVal);
+	return RightTool::tick(tickVal);
 }
 
-void ObjektTool::render( Bild &rObj )
+void ObjektTool::render(Bild& rObj)
 {
-    screenSize = rObj.getSize();
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return;
-    if( rObj.setDrawOptions( pos, gr ) )
-    {
-        objekte->render( rObj );
-        neuesObjekt->render( rObj );
-        model->render( rObj );
-        changeModel->render( rObj );
-        changeTextur->render( rObj );
-        stabilitätT->render( rObj );
-        stabilität->render( rObj );
-        energieT->render( rObj );
-        energie->render( rObj );
-        energieRadiusT->render( rObj );
-        energieRadius->render( rObj );
-        reparaturT->render( rObj );
-        reparatur->render( rObj );
-        akkuLeistungT->render( rObj );
-        akkuLeistung->render( rObj );
-        verwundbar->render( rObj );
-        beweglich->render( rObj );
-        collision->render( rObj );
-        laserCollision->render( rObj );
-        neutral->render( rObj );
-        erfahrung->render( rObj );
-        lebensAnzeige->render( rObj );
-        speichern->render( rObj );
-        löschen->render( rObj );
-        team->render( rObj );
-        rObj.releaseDrawOptions();
-    }
+	screenSize = rObj.getSize();
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return;
+	if (rObj.setDrawOptions(pos, gr))
+	{
+		objekte->render(rObj);
+		neuesObjekt->render(rObj);
+		model->render(rObj);
+		changeModel->render(rObj);
+		changeTextur->render(rObj);
+		stabilitätT->render(rObj);
+		stabilität->render(rObj);
+		energieT->render(rObj);
+		energie->render(rObj);
+		energieRadiusT->render(rObj);
+		energieRadius->render(rObj);
+		reparaturT->render(rObj);
+		reparatur->render(rObj);
+		akkuLeistungT->render(rObj);
+		akkuLeistung->render(rObj);
+		verwundbar->render(rObj);
+		beweglich->render(rObj);
+		collision->render(rObj);
+		laserCollision->render(rObj);
+		neutral->render(rObj);
+		erfahrung->render(rObj);
+		lebensAnzeige->render(rObj);
+		speichern->render(rObj);
+		löschen->render(rObj);
+		team->render(rObj);
+		rObj.releaseDrawOptions();
+	}
 }
 
-void ObjektTool::renderDialogs( Bild &rObj )
+void ObjektTool::renderDialogs(Bild& rObj)
 {
-    cs.lock();
-    if( dialog )
-        dialog->render( rObj );
-    cs.unlock();
+	cs.lock();
+	if (dialog)
+		dialog->render(rObj);
+	cs.unlock();
 }
 
-void ObjektTool::selectObject( int id )
+void ObjektTool::selectObject(int id)
 {
-    if( id == 0 )
-    {
-        model->removeStyle( M2DVorschau::Style::Sichtbar );
-        changeModel->removeStyle( M2DVorschau::Style::Sichtbar );
-        changeTextur->removeStyle( M2DVorschau::Style::Sichtbar );
-        stabilitätT->removeStyle( M2DVorschau::Style::Sichtbar );
-        stabilität->removeStyle( M2DVorschau::Style::Sichtbar );
-        energieT->removeStyle( M2DVorschau::Style::Sichtbar );
-        energie->removeStyle( M2DVorschau::Style::Sichtbar );
-        energieRadiusT->removeStyle( M2DVorschau::Style::Sichtbar );
-        energieRadius->removeStyle( M2DVorschau::Style::Sichtbar );
-        reparaturT->removeStyle( M2DVorschau::Style::Sichtbar );
-        reparatur->removeStyle( M2DVorschau::Style::Sichtbar );
-        akkuLeistungT->removeStyle( M2DVorschau::Style::Sichtbar );
-        akkuLeistung->removeStyle( M2DVorschau::Style::Sichtbar );
-        team->removeStyle( M2DVorschau::Style::Sichtbar );
-        verwundbar->removeStyle( KontrollKnopf::Style::Sichtbar );
-        beweglich->removeStyle( KontrollKnopf::Style::Sichtbar );
-        collision->removeStyle( KontrollKnopf::Style::Sichtbar );
-        laserCollision->removeStyle( KontrollKnopf::Style::Sichtbar );
-        neutral->removeStyle( KontrollKnopf::Style::Sichtbar );
-        erfahrung->removeStyle( KontrollKnopf::Style::Sichtbar );
-        lebensAnzeige->removeStyle( KontrollKnopf::Style::Sichtbar );
-        speichern->removeStyle( M2DVorschau::Style::Sichtbar );
-        löschen->removeStyle( KontrollKnopf::Style::Sichtbar );
-    }
-    else
-    {
-        int index = 0;
-        int anz = objekte->getEintragAnzahl();
-        for( int i = 0; i < anz; i++ )
-        {
-            if( objekte->zEintrag( i )->zText()->istGleich( Text( id ) ) )
-                break;
-            index++;
-        }
-        objekte->setAuswahl( index );
-        ObjektDaten *o = daten->getObjekt( daten->getObjektIndexById( id ) );
-        model->setModel2D( daten->loadModelFromRessource( o->m2d ) );
-        model->zModel()->addStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Erlaubt );
-        modelPath = daten->getResource( daten->getResourceIndexById( o->m2d ) )->path;
-        Textur2D *textur = new Textur2D();
-        textur->setTexturZ( daten->loadBildFromRessource( o->bild ) );
-        texturPath = daten->getResource( daten->getResourceIndexById( o->bild ) )->path;
-        model->zModel()->setTextur( textur );
-        stabilität->setText( Text( o->maxStabilität ) );
-        energie->setText( Text( o->maxEnergie ) );
-        energieRadius->setText( Text( o->energieRadius ) );
-        reparatur->setText( Text( o->reparatur ) );
-        akkuLeistung->setText( Text( o->akkuLeistung ) );
-        team->setAuswahl( Text( o->team ) );
-        model->addStyle( M2DVorschau::Style::Sichtbar );
-        verwundbar->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x1 ) == o->style );
-        beweglich->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x2 ) == o->style );
-        collision->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x4 ) == o->style );
-        laserCollision->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x8 ) == o->style );
-        neutral->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x10 ) == o->style );
-        erfahrung->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x20 ) == o->style );
-        lebensAnzeige->setStyle( KontrollKnopf::Style::Selected, ( o->style | 0x40 ) == o->style );
-        changeModel->addStyle( M2DVorschau::Style::Sichtbar );
-        changeTextur->addStyle( M2DVorschau::Style::Sichtbar );
-        stabilitätT->addStyle( M2DVorschau::Style::Sichtbar );
-        stabilität->addStyle( M2DVorschau::Style::Sichtbar );
-        energieT->addStyle( M2DVorschau::Style::Sichtbar );
-        energie->addStyle( M2DVorschau::Style::Sichtbar );
-        energieRadiusT->addStyle( M2DVorschau::Style::Sichtbar );
-        energieRadius->addStyle( M2DVorschau::Style::Sichtbar );
-        reparaturT->addStyle( M2DVorschau::Style::Sichtbar );
-        reparatur->addStyle( M2DVorschau::Style::Sichtbar );
-        akkuLeistungT->addStyle( M2DVorschau::Style::Sichtbar );
-        akkuLeistung->addStyle( M2DVorschau::Style::Sichtbar );
-        team->addStyle( M2DVorschau::Style::Sichtbar );
-        verwundbar->addStyle( KontrollKnopf::Style::Sichtbar );
-        beweglich->addStyle( KontrollKnopf::Style::Sichtbar );
-        collision->addStyle( KontrollKnopf::Style::Sichtbar );
-        laserCollision->addStyle( KontrollKnopf::Style::Sichtbar );
-        neutral->addStyle( KontrollKnopf::Style::Sichtbar );
-        erfahrung->addStyle( KontrollKnopf::Style::Sichtbar );
-        lebensAnzeige->addStyle( KontrollKnopf::Style::Sichtbar );
-        speichern->addStyle( M2DVorschau::Style::Sichtbar );
-        löschen->addStyle( KontrollKnopf::Style::Sichtbar );
-    }
+	if (id == 0)
+	{
+		model->removeStyle(M2DVorschau::Style::Sichtbar);
+		changeModel->removeStyle(M2DVorschau::Style::Sichtbar);
+		changeTextur->removeStyle(M2DVorschau::Style::Sichtbar);
+		stabilitätT->removeStyle(M2DVorschau::Style::Sichtbar);
+		stabilität->removeStyle(M2DVorschau::Style::Sichtbar);
+		energieT->removeStyle(M2DVorschau::Style::Sichtbar);
+		energie->removeStyle(M2DVorschau::Style::Sichtbar);
+		energieRadiusT->removeStyle(M2DVorschau::Style::Sichtbar);
+		energieRadius->removeStyle(M2DVorschau::Style::Sichtbar);
+		reparaturT->removeStyle(M2DVorschau::Style::Sichtbar);
+		reparatur->removeStyle(M2DVorschau::Style::Sichtbar);
+		akkuLeistungT->removeStyle(M2DVorschau::Style::Sichtbar);
+		akkuLeistung->removeStyle(M2DVorschau::Style::Sichtbar);
+		team->removeStyle(M2DVorschau::Style::Sichtbar);
+		verwundbar->removeStyle(KontrollKnopf::Style::Sichtbar);
+		beweglich->removeStyle(KontrollKnopf::Style::Sichtbar);
+		collision->removeStyle(KontrollKnopf::Style::Sichtbar);
+		laserCollision->removeStyle(KontrollKnopf::Style::Sichtbar);
+		neutral->removeStyle(KontrollKnopf::Style::Sichtbar);
+		erfahrung->removeStyle(KontrollKnopf::Style::Sichtbar);
+		lebensAnzeige->removeStyle(KontrollKnopf::Style::Sichtbar);
+		speichern->removeStyle(M2DVorschau::Style::Sichtbar);
+		löschen->removeStyle(KontrollKnopf::Style::Sichtbar);
+	}
+	else
+	{
+		int index = 0;
+		int anz = objekte->getEintragAnzahl();
+		for (int i = 0; i < anz; i++)
+		{
+			if (objekte->zEintrag(i)->zText()->istGleich(Text(id)))
+				break;
+			index++;
+		}
+		objekte->setAuswahl(index);
+		ObjektDaten* o = daten->getObjekt(daten->getObjektIndexById(id));
+		model->setModel2D(daten->loadModelFromRessource(o->m2d));
+		model->zModel()->addStyle(Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Erlaubt);
+		modelPath = daten->getResource(daten->getResourceIndexById(o->m2d))->path;
+		Textur2D* textur = new Textur2D();
+		textur->setTexturZ(daten->loadBildFromRessource(o->bild));
+		texturPath = daten->getResource(daten->getResourceIndexById(o->bild))->path;
+		model->zModel()->setTextur(textur);
+		stabilität->setText(Text(o->maxStabilität));
+		energie->setText(Text(o->maxEnergie));
+		energieRadius->setText(Text(o->energieRadius));
+		reparatur->setText(Text(o->reparatur));
+		akkuLeistung->setText(Text(o->akkuLeistung));
+		team->setAuswahl((int)o->team);
+		model->addStyle(M2DVorschau::Style::Sichtbar);
+		verwundbar->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x1) == o->style);
+		beweglich->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x2) == o->style);
+		collision->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x4) == o->style);
+		laserCollision->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x8) == o->style);
+		neutral->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x10) == o->style);
+		erfahrung->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x20) == o->style);
+		lebensAnzeige->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x40) == o->style);
+		changeModel->addStyle(M2DVorschau::Style::Sichtbar);
+		changeTextur->addStyle(M2DVorschau::Style::Sichtbar);
+		stabilitätT->addStyle(M2DVorschau::Style::Sichtbar);
+		stabilität->addStyle(M2DVorschau::Style::Sichtbar);
+		energieT->addStyle(M2DVorschau::Style::Sichtbar);
+		energie->addStyle(M2DVorschau::Style::Sichtbar);
+		energieRadiusT->addStyle(M2DVorschau::Style::Sichtbar);
+		energieRadius->addStyle(M2DVorschau::Style::Sichtbar);
+		reparaturT->addStyle(M2DVorschau::Style::Sichtbar);
+		reparatur->addStyle(M2DVorschau::Style::Sichtbar);
+		akkuLeistungT->addStyle(M2DVorschau::Style::Sichtbar);
+		akkuLeistung->addStyle(M2DVorschau::Style::Sichtbar);
+		team->addStyle(M2DVorschau::Style::Sichtbar);
+		verwundbar->addStyle(KontrollKnopf::Style::Sichtbar);
+		beweglich->addStyle(KontrollKnopf::Style::Sichtbar);
+		collision->addStyle(KontrollKnopf::Style::Sichtbar);
+		laserCollision->addStyle(KontrollKnopf::Style::Sichtbar);
+		neutral->addStyle(KontrollKnopf::Style::Sichtbar);
+		erfahrung->addStyle(KontrollKnopf::Style::Sichtbar);
+		lebensAnzeige->addStyle(KontrollKnopf::Style::Sichtbar);
+		speichern->addStyle(M2DVorschau::Style::Sichtbar);
+		löschen->addStyle(KontrollKnopf::Style::Sichtbar);
+	}
 }

Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.cpp

@@ -4,287 +4,287 @@
 
 using namespace Editor;
 
-SpielerTool::SpielerTool( UIInit &uiFactory, KarteDaten *daten )
-    : RightTool()
+SpielerTool::SpielerTool(UIInit& uiFactory, KarteDaten* daten)
+	: RightTool()
 {
-    int spielerAnzahl = daten->getSpielerAnzahl();
-    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        spielerAuswahl->addEintrag( new Text( Text( "Spieler " ) += ( i + 1 ) ) );
-    }
-    spielerAuswahl->setEventAktion( [this]( void *p, AuswahlBox *a, int old, int auswahl )
-    {
-        this->selectPlayer( auswahl + 1 );
-    } );
-    skillStartT = initTextFeld( 0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
-    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität" );
-    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie" );
-    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur" );
-    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku" );
-    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit" );
-    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung" );
-    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz" );
-    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität" );
-    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz" );
-    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo" );
-    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild" );
-    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz" );
-    skillStartNetzwerkT = initTextFeld( 0, 355, 200, 20, uiFactory, TextFeld::Style::Text, "Netzwerk" );
-    skillStartPunkteT = initTextFeld( 0, 380, 200, 20, uiFactory, TextFeld::Style::Text, "Punkte" );
-    SpielerDaten *spieler = daten->getSpieler( daten->getSpielerIndexById( 1 ) );
-    skillStartStabilität = initTextFeld( 200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->maxStabilität ) );
-    skillStartEnergie = initTextFeld( 200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->maxEnergie ) );
-    skillStartReparatur = initTextFeld( 200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->reparatur ) );
-    skillStartAkku = initTextFeld( 200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->akkuLeistung ) );
-    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->wendigkeit ) );
-    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->beschleunigung ) );
-    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->antriebEffizienz ) );
-    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->laserIntensität ) );
-    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->laserEffizienz ) );
-    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->laserTempo ) );
-    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->energieSchild ) );
-    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->energieSchildEffizienz ) );
-    skillStartNetzwerk = initTextFeld( 200, 355, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->netzwerk ) );
-    skillStartPunkte = initTextFeld( 200, 380, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->skillPunkte ) );
-    speichern = initKnopf( 0, 405, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern" );
-    this->daten = daten;
+	int spielerAnzahl = daten->getSpielerAnzahl();
+	spielerAuswahl = initAuswahlBox(0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {});
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		spielerAuswahl->addEintrag(new Text(Text("Spieler ") += (i + 1)));
+	}
+	spielerAuswahl->setEventAktion([this](void* p, AuswahlBox* a, int old, int auswahl)
+		{
+			this->selectPlayer(auswahl + 1);
+		});
+	skillStartT = initTextFeld(0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---");
+	skillStartStabilitätT = initTextFeld(0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität");
+	skillStartEnergieT = initTextFeld(0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie");
+	skillStartReparaturT = initTextFeld(0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur");
+	skillStartAkkuT = initTextFeld(0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku");
+	skillStartWendigkeitT = initTextFeld(0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit");
+	skillStartBeschleunigungT = initTextFeld(0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung");
+	skillStartAntriebEffizienzT = initTextFeld(0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz");
+	skillStartLaserIntensitätT = initTextFeld(0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität");
+	skillStartLaserEffizienzT = initTextFeld(0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz");
+	skillStartLaserTempoT = initTextFeld(0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo");
+	skillStartEnergieSchildT = initTextFeld(0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild");
+	skillStartEnergieSchildEffizienzT = initTextFeld(0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz");
+	skillStartNetzwerkT = initTextFeld(0, 355, 200, 20, uiFactory, TextFeld::Style::Text, "Netzwerk");
+	skillStartPunkteT = initTextFeld(0, 380, 200, 20, uiFactory, TextFeld::Style::Text, "Punkte");
+	SpielerDaten* spieler = daten->getSpieler(daten->getSpielerIndexById(1));
+	skillStartStabilität = initTextFeld(200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->maxStabilität));
+	skillStartEnergie = initTextFeld(200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->maxEnergie));
+	skillStartReparatur = initTextFeld(200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->reparatur));
+	skillStartAkku = initTextFeld(200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->akkuLeistung));
+	skillStartWendigkeit = initTextFeld(200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->wendigkeit));
+	skillStartBeschleunigung = initTextFeld(200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->beschleunigung));
+	skillStartAntriebEffizienz = initTextFeld(200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->antriebEffizienz));
+	skillStartLaserIntensität = initTextFeld(200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->laserIntensität));
+	skillStartLaserEffizienz = initTextFeld(200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->laserEffizienz));
+	skillStartLaserTempo = initTextFeld(200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->laserTempo));
+	skillStartEnergieSchild = initTextFeld(200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->energieSchild));
+	skillStartEnergieSchildEffizienz = initTextFeld(200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->energieSchildEffizienz));
+	skillStartNetzwerk = initTextFeld(200, 355, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->netzwerk));
+	skillStartPunkte = initTextFeld(200, 380, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->skillPunkte));
+	speichern = initKnopf(0, 405, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern");
+	this->daten = daten;
 }
 
 SpielerTool::~SpielerTool()
 {
-    spielerAuswahl->release();
-    skillStartT->release();
-    skillStartStabilitätT->release();
-    skillStartEnergieT->release();
-    skillStartReparaturT->release();
-    skillStartAkkuT->release();
-    skillStartWendigkeitT->release();
-    skillStartBeschleunigungT->release();
-    skillStartAntriebEffizienzT->release();
-    skillStartLaserIntensitätT->release();
-    skillStartLaserEffizienzT->release();
-    skillStartLaserTempoT->release();
-    skillStartEnergieSchildT->release();
-    skillStartEnergieSchildEffizienzT->release();
-    skillStartNetzwerkT->release();
-    skillStartPunkteT->release();
-    skillStartStabilität->release();
-    skillStartEnergie->release();
-    skillStartReparatur->release();
-    skillStartAkku->release();
-    skillStartWendigkeit->release();
-    skillStartBeschleunigung->release();
-    skillStartAntriebEffizienz->release();
-    skillStartLaserIntensität->release();
-    skillStartLaserEffizienz->release();
-    skillStartLaserTempo->release();
-    skillStartEnergieSchild->release();
-    skillStartEnergieSchildEffizienz->release();
-    skillStartNetzwerk->release();
-    skillStartPunkte->release();
-    speichern->release();
-    daten->release();
+	spielerAuswahl->release();
+	skillStartT->release();
+	skillStartStabilitätT->release();
+	skillStartEnergieT->release();
+	skillStartReparaturT->release();
+	skillStartAkkuT->release();
+	skillStartWendigkeitT->release();
+	skillStartBeschleunigungT->release();
+	skillStartAntriebEffizienzT->release();
+	skillStartLaserIntensitätT->release();
+	skillStartLaserEffizienzT->release();
+	skillStartLaserTempoT->release();
+	skillStartEnergieSchildT->release();
+	skillStartEnergieSchildEffizienzT->release();
+	skillStartNetzwerkT->release();
+	skillStartPunkteT->release();
+	skillStartStabilität->release();
+	skillStartEnergie->release();
+	skillStartReparatur->release();
+	skillStartAkku->release();
+	skillStartWendigkeit->release();
+	skillStartBeschleunigung->release();
+	skillStartAntriebEffizienz->release();
+	skillStartLaserIntensität->release();
+	skillStartLaserEffizienz->release();
+	skillStartLaserTempo->release();
+	skillStartEnergieSchild->release();
+	skillStartEnergieSchildEffizienz->release();
+	skillStartNetzwerk->release();
+	skillStartPunkte->release();
+	speichern->release();
+	daten->release();
 }
 
-void SpielerTool::doPublicMausEreignis( MausEreignis &me )
+void SpielerTool::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        me.verarbeitet = 1;
-    me.mx -= pos.x;
-    me.my -= pos.y;
-    spielerAuswahl->doPublicMausEreignis( me );
-    skillStartT->doPublicMausEreignis( me );
-    skillStartStabilitätT->doPublicMausEreignis( me );
-    skillStartEnergieT->doPublicMausEreignis( me );
-    skillStartReparaturT->doPublicMausEreignis( me );
-    skillStartAkkuT->doPublicMausEreignis( me );
-    skillStartWendigkeitT->doPublicMausEreignis( me );
-    skillStartBeschleunigungT->doPublicMausEreignis( me );
-    skillStartAntriebEffizienzT->doPublicMausEreignis( me );
-    skillStartLaserIntensitätT->doPublicMausEreignis( me );
-    skillStartLaserEffizienzT->doPublicMausEreignis( me );
-    skillStartLaserTempoT->doPublicMausEreignis( me );
-    skillStartEnergieSchildT->doPublicMausEreignis( me );
-    skillStartEnergieSchildEffizienzT->doPublicMausEreignis( me );
-    skillStartNetzwerkT->doPublicMausEreignis( me );
-    skillStartPunkteT->doPublicMausEreignis( me );
-    skillStartStabilität->doPublicMausEreignis( me );
-    skillStartEnergie->doPublicMausEreignis( me );
-    skillStartReparatur->doPublicMausEreignis( me );
-    skillStartAkku->doPublicMausEreignis( me );
-    skillStartWendigkeit->doPublicMausEreignis( me );
-    skillStartBeschleunigung->doPublicMausEreignis( me );
-    skillStartAntriebEffizienz->doPublicMausEreignis( me );
-    skillStartLaserIntensität->doPublicMausEreignis( me );
-    skillStartLaserEffizienz->doPublicMausEreignis( me );
-    skillStartLaserTempo->doPublicMausEreignis( me );
-    skillStartEnergieSchild->doPublicMausEreignis( me );
-    skillStartEnergieSchildEffizienz->doPublicMausEreignis( me );
-    skillStartNetzwerk->doPublicMausEreignis( me );
-    skillStartPunkte->doPublicMausEreignis( me );
-    bool verarbeitet = me.verarbeitet;
-    speichern->doPublicMausEreignis( me );
-    if( !verarbeitet && me.verarbeitet && me.id == ME_RLinks )
-    {
-        SpielerDaten *data = daten->getSpieler( daten->getSpielerIndexById( spielerAuswahl->getAuswahl() + 1 ) );
-        data->maxStabilität = *skillStartStabilität->zText();
-        data->maxEnergie = *skillStartEnergie->zText();
-        data->reparatur = *skillStartReparatur->zText();
-        data->akkuLeistung = *skillStartAkku->zText();
-        data->wendigkeit = *skillStartWendigkeit->zText();
-        data->beschleunigung = *skillStartBeschleunigung->zText();
-        data->antriebEffizienz = *skillStartAntriebEffizienz->zText();
-        data->laserIntensität = *skillStartLaserIntensität->zText();
-        data->laserEffizienz = *skillStartLaserEffizienz->zText();
-        data->laserTempo = *skillStartLaserTempo->zText();
-        data->energieSchild = *skillStartEnergieSchild->zText();
-        data->energieSchildEffizienz = *skillStartEnergieSchildEffizienz->zText();
-        data->netzwerk = *skillStartNetzwerk->zText();
-        data->skillPunkte = *skillStartPunkte->zText();
-        data->update();
-    }
-    me.mx += pos.x;
-    me.my += pos.y;
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        me.verarbeitet = vera;
+	bool vera = me.verarbeitet;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		me.verarbeitet = 1;
+	me.mx -= pos.x;
+	me.my -= pos.y;
+	spielerAuswahl->doPublicMausEreignis(me);
+	skillStartT->doPublicMausEreignis(me);
+	skillStartStabilitätT->doPublicMausEreignis(me);
+	skillStartEnergieT->doPublicMausEreignis(me);
+	skillStartReparaturT->doPublicMausEreignis(me);
+	skillStartAkkuT->doPublicMausEreignis(me);
+	skillStartWendigkeitT->doPublicMausEreignis(me);
+	skillStartBeschleunigungT->doPublicMausEreignis(me);
+	skillStartAntriebEffizienzT->doPublicMausEreignis(me);
+	skillStartLaserIntensitätT->doPublicMausEreignis(me);
+	skillStartLaserEffizienzT->doPublicMausEreignis(me);
+	skillStartLaserTempoT->doPublicMausEreignis(me);
+	skillStartEnergieSchildT->doPublicMausEreignis(me);
+	skillStartEnergieSchildEffizienzT->doPublicMausEreignis(me);
+	skillStartNetzwerkT->doPublicMausEreignis(me);
+	skillStartPunkteT->doPublicMausEreignis(me);
+	skillStartStabilität->doPublicMausEreignis(me);
+	skillStartEnergie->doPublicMausEreignis(me);
+	skillStartReparatur->doPublicMausEreignis(me);
+	skillStartAkku->doPublicMausEreignis(me);
+	skillStartWendigkeit->doPublicMausEreignis(me);
+	skillStartBeschleunigung->doPublicMausEreignis(me);
+	skillStartAntriebEffizienz->doPublicMausEreignis(me);
+	skillStartLaserIntensität->doPublicMausEreignis(me);
+	skillStartLaserEffizienz->doPublicMausEreignis(me);
+	skillStartLaserTempo->doPublicMausEreignis(me);
+	skillStartEnergieSchild->doPublicMausEreignis(me);
+	skillStartEnergieSchildEffizienz->doPublicMausEreignis(me);
+	skillStartNetzwerk->doPublicMausEreignis(me);
+	skillStartPunkte->doPublicMausEreignis(me);
+	bool verarbeitet = me.verarbeitet;
+	speichern->doPublicMausEreignis(me);
+	if (!verarbeitet && me.verarbeitet && me.id == ME_RLinks)
+	{
+		SpielerDaten* data = daten->getSpieler(daten->getSpielerIndexById(spielerAuswahl->getAuswahl() + 1));
+		data->maxStabilität = (int)*skillStartStabilität->zText();
+		data->maxEnergie = (int)*skillStartEnergie->zText();
+		data->reparatur = (double)*skillStartReparatur->zText();
+		data->akkuLeistung = (double)*skillStartAkku->zText();
+		data->wendigkeit = (double)*skillStartWendigkeit->zText();
+		data->beschleunigung = (double)*skillStartBeschleunigung->zText();
+		data->antriebEffizienz = (double)*skillStartAntriebEffizienz->zText();
+		data->laserIntensität = (int)*skillStartLaserIntensität->zText();
+		data->laserEffizienz = (int)*skillStartLaserEffizienz->zText();
+		data->laserTempo = (int)*skillStartLaserTempo->zText();
+		data->energieSchild = (double)*skillStartEnergieSchild->zText();
+		data->energieSchildEffizienz = (double)*skillStartEnergieSchildEffizienz->zText();
+		data->netzwerk = (int)*skillStartNetzwerk->zText();
+		data->skillPunkte = (int)*skillStartPunkte->zText();
+		data->update();
+	}
+	me.mx += pos.x;
+	me.my += pos.y;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		me.verarbeitet = vera;
 }
 
-void SpielerTool::doTastaturEreignis( TastaturEreignis &te )
+void SpielerTool::doTastaturEreignis(TastaturEreignis& te)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return;
-    spielerAuswahl->doTastaturEreignis( te );
-    skillStartT->doTastaturEreignis( te );
-    skillStartStabilitätT->doTastaturEreignis( te );
-    skillStartEnergieT->doTastaturEreignis( te );
-    skillStartReparaturT->doTastaturEreignis( te );
-    skillStartAkkuT->doTastaturEreignis( te );
-    skillStartWendigkeitT->doTastaturEreignis( te );
-    skillStartBeschleunigungT->doTastaturEreignis( te );
-    skillStartAntriebEffizienzT->doTastaturEreignis( te );
-    skillStartLaserIntensitätT->doTastaturEreignis( te );
-    skillStartLaserEffizienzT->doTastaturEreignis( te );
-    skillStartLaserTempoT->doTastaturEreignis( te );
-    skillStartEnergieSchildT->doTastaturEreignis( te );
-    skillStartEnergieSchildEffizienzT->doTastaturEreignis( te );
-    skillStartNetzwerkT->doTastaturEreignis( te );
-    skillStartPunkteT->doTastaturEreignis( te );
-    skillStartStabilität->doTastaturEreignis( te );
-    skillStartEnergie->doTastaturEreignis( te );
-    skillStartReparatur->doTastaturEreignis( te );
-    skillStartAkku->doTastaturEreignis( te );
-    skillStartWendigkeit->doTastaturEreignis( te );
-    skillStartBeschleunigung->doTastaturEreignis( te );
-    skillStartAntriebEffizienz->doTastaturEreignis( te );
-    skillStartLaserIntensität->doTastaturEreignis( te );
-    skillStartLaserEffizienz->doTastaturEreignis( te );
-    skillStartLaserTempo->doTastaturEreignis( te );
-    skillStartEnergieSchild->doTastaturEreignis( te );
-    skillStartEnergieSchildEffizienz->doTastaturEreignis( te );
-    skillStartNetzwerk->doTastaturEreignis( te );
-    skillStartPunkte->doTastaturEreignis( te );
-    speichern->doTastaturEreignis( te );
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return;
+	spielerAuswahl->doTastaturEreignis(te);
+	skillStartT->doTastaturEreignis(te);
+	skillStartStabilitätT->doTastaturEreignis(te);
+	skillStartEnergieT->doTastaturEreignis(te);
+	skillStartReparaturT->doTastaturEreignis(te);
+	skillStartAkkuT->doTastaturEreignis(te);
+	skillStartWendigkeitT->doTastaturEreignis(te);
+	skillStartBeschleunigungT->doTastaturEreignis(te);
+	skillStartAntriebEffizienzT->doTastaturEreignis(te);
+	skillStartLaserIntensitätT->doTastaturEreignis(te);
+	skillStartLaserEffizienzT->doTastaturEreignis(te);
+	skillStartLaserTempoT->doTastaturEreignis(te);
+	skillStartEnergieSchildT->doTastaturEreignis(te);
+	skillStartEnergieSchildEffizienzT->doTastaturEreignis(te);
+	skillStartNetzwerkT->doTastaturEreignis(te);
+	skillStartPunkteT->doTastaturEreignis(te);
+	skillStartStabilität->doTastaturEreignis(te);
+	skillStartEnergie->doTastaturEreignis(te);
+	skillStartReparatur->doTastaturEreignis(te);
+	skillStartAkku->doTastaturEreignis(te);
+	skillStartWendigkeit->doTastaturEreignis(te);
+	skillStartBeschleunigung->doTastaturEreignis(te);
+	skillStartAntriebEffizienz->doTastaturEreignis(te);
+	skillStartLaserIntensität->doTastaturEreignis(te);
+	skillStartLaserEffizienz->doTastaturEreignis(te);
+	skillStartLaserTempo->doTastaturEreignis(te);
+	skillStartEnergieSchild->doTastaturEreignis(te);
+	skillStartEnergieSchildEffizienz->doTastaturEreignis(te);
+	skillStartNetzwerk->doTastaturEreignis(te);
+	skillStartPunkte->doTastaturEreignis(te);
+	speichern->doTastaturEreignis(te);
 }
 
-bool SpielerTool::tick( double tickVal )
+bool SpielerTool::tick(double tickVal)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return __super::tick( tickVal );
-    bool ret = __super::tick( tickVal );
-    ret |= spielerAuswahl->tick( tickVal );
-    ret |= skillStartT->tick( tickVal );
-    ret |= skillStartStabilitätT->tick( tickVal );
-    ret |= skillStartEnergieT->tick( tickVal );
-    ret |= skillStartReparaturT->tick( tickVal );
-    ret |= skillStartAkkuT->tick( tickVal );
-    ret |= skillStartWendigkeitT->tick( tickVal );
-    ret |= skillStartBeschleunigungT->tick( tickVal );
-    ret |= skillStartAntriebEffizienzT->tick( tickVal );
-    ret |= skillStartLaserIntensitätT->tick( tickVal );
-    ret |= skillStartLaserEffizienzT->tick( tickVal );
-    ret |= skillStartLaserTempoT->tick( tickVal );
-    ret |= skillStartEnergieSchildT->tick( tickVal );
-    ret |= skillStartEnergieSchildEffizienzT->tick( tickVal );
-    ret |= skillStartNetzwerkT->tick( tickVal );
-    ret |= skillStartPunkteT->tick( tickVal );
-    ret |= skillStartStabilität->tick( tickVal );
-    ret |= skillStartEnergie->tick( tickVal );
-    ret |= skillStartReparatur->tick( tickVal );
-    ret |= skillStartAkku->tick( tickVal );
-    ret |= skillStartWendigkeit->tick( tickVal );
-    ret |= skillStartBeschleunigung->tick( tickVal );
-    ret |= skillStartAntriebEffizienz->tick( tickVal );
-    ret |= skillStartLaserIntensität->tick( tickVal );
-    ret |= skillStartLaserEffizienz->tick( tickVal );
-    ret |= skillStartLaserTempo->tick( tickVal );
-    ret |= skillStartEnergieSchild->tick( tickVal );
-    ret |= skillStartEnergieSchildEffizienz->tick( tickVal );
-    ret |= skillStartNetzwerk->tick( tickVal );
-    ret |= skillStartPunkte->tick( tickVal );
-    ret |= speichern->tick( tickVal );
-    return ret;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return __super::tick(tickVal);
+	bool ret = __super::tick(tickVal);
+	ret |= spielerAuswahl->tick(tickVal);
+	ret |= skillStartT->tick(tickVal);
+	ret |= skillStartStabilitätT->tick(tickVal);
+	ret |= skillStartEnergieT->tick(tickVal);
+	ret |= skillStartReparaturT->tick(tickVal);
+	ret |= skillStartAkkuT->tick(tickVal);
+	ret |= skillStartWendigkeitT->tick(tickVal);
+	ret |= skillStartBeschleunigungT->tick(tickVal);
+	ret |= skillStartAntriebEffizienzT->tick(tickVal);
+	ret |= skillStartLaserIntensitätT->tick(tickVal);
+	ret |= skillStartLaserEffizienzT->tick(tickVal);
+	ret |= skillStartLaserTempoT->tick(tickVal);
+	ret |= skillStartEnergieSchildT->tick(tickVal);
+	ret |= skillStartEnergieSchildEffizienzT->tick(tickVal);
+	ret |= skillStartNetzwerkT->tick(tickVal);
+	ret |= skillStartPunkteT->tick(tickVal);
+	ret |= skillStartStabilität->tick(tickVal);
+	ret |= skillStartEnergie->tick(tickVal);
+	ret |= skillStartReparatur->tick(tickVal);
+	ret |= skillStartAkku->tick(tickVal);
+	ret |= skillStartWendigkeit->tick(tickVal);
+	ret |= skillStartBeschleunigung->tick(tickVal);
+	ret |= skillStartAntriebEffizienz->tick(tickVal);
+	ret |= skillStartLaserIntensität->tick(tickVal);
+	ret |= skillStartLaserEffizienz->tick(tickVal);
+	ret |= skillStartLaserTempo->tick(tickVal);
+	ret |= skillStartEnergieSchild->tick(tickVal);
+	ret |= skillStartEnergieSchildEffizienz->tick(tickVal);
+	ret |= skillStartNetzwerk->tick(tickVal);
+	ret |= skillStartPunkte->tick(tickVal);
+	ret |= speichern->tick(tickVal);
+	return ret;
 }
 
-void SpielerTool::render( Bild &rObj )
+void SpielerTool::render(Bild& rObj)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return;
-    if( rObj.setDrawOptions( pos, gr ) )
-    {
-        skillStartT->render( rObj );
-        skillStartStabilitätT->render( rObj );
-        skillStartEnergieT->render( rObj );
-        skillStartReparaturT->render( rObj );
-        skillStartAkkuT->render( rObj );
-        skillStartWendigkeitT->render( rObj );
-        skillStartBeschleunigungT->render( rObj );
-        skillStartAntriebEffizienzT->render( rObj );
-        skillStartLaserIntensitätT->render( rObj );
-        skillStartLaserEffizienzT->render( rObj );
-        skillStartLaserTempoT->render( rObj );
-        skillStartEnergieSchildT->render( rObj );
-        skillStartEnergieSchildEffizienzT->render( rObj );
-        skillStartNetzwerkT->render( rObj );
-        skillStartPunkteT->render( rObj );
-        skillStartStabilität->render( rObj );
-        skillStartEnergie->render( rObj );
-        skillStartReparatur->render( rObj );
-        skillStartAkku->render( rObj );
-        skillStartWendigkeit->render( rObj );
-        skillStartBeschleunigung->render( rObj );
-        skillStartAntriebEffizienz->render( rObj );
-        skillStartLaserIntensität->render( rObj );
-        skillStartLaserEffizienz->render( rObj );
-        skillStartLaserTempo->render( rObj );
-        skillStartEnergieSchild->render( rObj );
-        skillStartEnergieSchildEffizienz->render( rObj );
-        skillStartNetzwerk->render( rObj );
-        skillStartPunkte->render( rObj );
-        speichern->render( rObj );
-        spielerAuswahl->render( rObj );
-        rObj.releaseDrawOptions();
-    }
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return;
+	if (rObj.setDrawOptions(pos, gr))
+	{
+		skillStartT->render(rObj);
+		skillStartStabilitätT->render(rObj);
+		skillStartEnergieT->render(rObj);
+		skillStartReparaturT->render(rObj);
+		skillStartAkkuT->render(rObj);
+		skillStartWendigkeitT->render(rObj);
+		skillStartBeschleunigungT->render(rObj);
+		skillStartAntriebEffizienzT->render(rObj);
+		skillStartLaserIntensitätT->render(rObj);
+		skillStartLaserEffizienzT->render(rObj);
+		skillStartLaserTempoT->render(rObj);
+		skillStartEnergieSchildT->render(rObj);
+		skillStartEnergieSchildEffizienzT->render(rObj);
+		skillStartNetzwerkT->render(rObj);
+		skillStartPunkteT->render(rObj);
+		skillStartStabilität->render(rObj);
+		skillStartEnergie->render(rObj);
+		skillStartReparatur->render(rObj);
+		skillStartAkku->render(rObj);
+		skillStartWendigkeit->render(rObj);
+		skillStartBeschleunigung->render(rObj);
+		skillStartAntriebEffizienz->render(rObj);
+		skillStartLaserIntensität->render(rObj);
+		skillStartLaserEffizienz->render(rObj);
+		skillStartLaserTempo->render(rObj);
+		skillStartEnergieSchild->render(rObj);
+		skillStartEnergieSchildEffizienz->render(rObj);
+		skillStartNetzwerk->render(rObj);
+		skillStartPunkte->render(rObj);
+		speichern->render(rObj);
+		spielerAuswahl->render(rObj);
+		rObj.releaseDrawOptions();
+	}
 }
 
-void SpielerTool::selectPlayer( int id )
+void SpielerTool::selectPlayer(int id)
 {
-    int index = daten->getSpielerIndexById( id );
-    spielerAuswahl->setAuswahl( id - 1 );
-    SpielerDaten *spieler = daten->getSpieler( index );
-    skillStartStabilität->setText( Text( spieler->maxStabilität ) );
-    skillStartEnergie->setText( Text( spieler->maxEnergie ) );
-    skillStartReparatur->setText( Text( spieler->reparatur ) );
-    skillStartAkku->setText( Text( spieler->akkuLeistung ) );
-    skillStartWendigkeit->setText( Text( spieler->wendigkeit ) );
-    skillStartBeschleunigung->setText( Text( spieler->beschleunigung ) );
-    skillStartAntriebEffizienz->setText( Text( spieler->antriebEffizienz ) );
-    skillStartLaserIntensität->setText( Text( spieler->laserIntensität ) );
-    skillStartLaserEffizienz->setText( Text( spieler->laserEffizienz ) );
-    skillStartLaserTempo->setText( Text( spieler->laserTempo ) );
-    skillStartEnergieSchild->setText( Text( spieler->energieSchild ) );
-    skillStartEnergieSchildEffizienz->setText( Text( spieler->energieSchildEffizienz ) );
-    skillStartNetzwerk->setText( Text( spieler->netzwerk ) );
-    skillStartPunkte->setText( Text( spieler->skillPunkte ) );
+	int index = daten->getSpielerIndexById(id);
+	spielerAuswahl->setAuswahl(id - 1);
+	SpielerDaten* spieler = daten->getSpieler(index);
+	skillStartStabilität->setText(Text(spieler->maxStabilität));
+	skillStartEnergie->setText(Text(spieler->maxEnergie));
+	skillStartReparatur->setText(Text(spieler->reparatur));
+	skillStartAkku->setText(Text(spieler->akkuLeistung));
+	skillStartWendigkeit->setText(Text(spieler->wendigkeit));
+	skillStartBeschleunigung->setText(Text(spieler->beschleunigung));
+	skillStartAntriebEffizienz->setText(Text(spieler->antriebEffizienz));
+	skillStartLaserIntensität->setText(Text(spieler->laserIntensität));
+	skillStartLaserEffizienz->setText(Text(spieler->laserEffizienz));
+	skillStartLaserTempo->setText(Text(spieler->laserTempo));
+	skillStartEnergieSchild->setText(Text(spieler->energieSchild));
+	skillStartEnergieSchildEffizienz->setText(Text(spieler->energieSchildEffizienz));
+	skillStartNetzwerk->setText(Text(spieler->netzwerk));
+	skillStartPunkte->setText(Text(spieler->skillPunkte));
 }

Asteroids/Editor/Interface/RightTools/TeamOptionen/TeamOptionen.cpp

@@ -4,259 +4,259 @@
 
 using namespace Editor;
 
-TeamTool::TeamTool( UIInit &uiFactory, KarteDaten *daten )
-    : RightTool()
+TeamTool::TeamTool(UIInit& uiFactory, KarteDaten* daten)
+	: RightTool()
 {
-    int teamAnzahl = daten->getTeamAnzahl();
-    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
-    for( int i = 0; i < teamAnzahl; i++ )
-    {
-        teamAuswahl->addEintrag( daten->getTeamName( i ) );
-    }
-    teamAuswahl->setEventAktion( [this]( void *p, AuswahlBox *a, int old, int auswahl )
-    {
-        this->selectTeam( auswahl + 1 );
-    } );
-    skillStartT = initTextFeld( 0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
-    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität" );
-    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie" );
-    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur" );
-    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku" );
-    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit" );
-    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung" );
-    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz" );
-    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität" );
-    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz" );
-    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo" );
-    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild" );
-    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz" );
-    TeamDaten *Team = daten->getTeam( daten->getTeamIndexById( 1 ) );
-    skillStartStabilität = initTextFeld( 200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->maxStabilität ) );
-    skillStartEnergie = initTextFeld( 200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->maxEnergie ) );
-    skillStartReparatur = initTextFeld( 200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->reparatur ) );
-    skillStartAkku = initTextFeld( 200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->akkuLeistung ) );
-    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->wendigkeit ) );
-    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->beschleunigung ) );
-    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->antriebEffizienz ) );
-    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->laserIntensität ) );
-    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->laserEffizienz ) );
-    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->laserTempo ) );
-    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->energieSchild ) );
-    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->energieSchildEffizienz ) );
-    speichern = initKnopf( 0, 380, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern" );
-    this->daten = daten;
+	int teamAnzahl = daten->getTeamAnzahl();
+	teamAuswahl = initAuswahlBox(0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {});
+	for (int i = 0; i < teamAnzahl; i++)
+	{
+		teamAuswahl->addEintrag(daten->getTeamName(i));
+	}
+	teamAuswahl->setEventAktion([this](void* p, AuswahlBox* a, int old, int auswahl)
+		{
+			this->selectTeam(auswahl + 1);
+		});
+	skillStartT = initTextFeld(0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---");
+	skillStartStabilitätT = initTextFeld(0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität");
+	skillStartEnergieT = initTextFeld(0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie");
+	skillStartReparaturT = initTextFeld(0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur");
+	skillStartAkkuT = initTextFeld(0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku");
+	skillStartWendigkeitT = initTextFeld(0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit");
+	skillStartBeschleunigungT = initTextFeld(0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung");
+	skillStartAntriebEffizienzT = initTextFeld(0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz");
+	skillStartLaserIntensitätT = initTextFeld(0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität");
+	skillStartLaserEffizienzT = initTextFeld(0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz");
+	skillStartLaserTempoT = initTextFeld(0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo");
+	skillStartEnergieSchildT = initTextFeld(0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild");
+	skillStartEnergieSchildEffizienzT = initTextFeld(0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz");
+	TeamDaten* Team = daten->getTeam(daten->getTeamIndexById(1));
+	skillStartStabilität = initTextFeld(200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->maxStabilität));
+	skillStartEnergie = initTextFeld(200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->maxEnergie));
+	skillStartReparatur = initTextFeld(200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->reparatur));
+	skillStartAkku = initTextFeld(200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->akkuLeistung));
+	skillStartWendigkeit = initTextFeld(200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->wendigkeit));
+	skillStartBeschleunigung = initTextFeld(200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->beschleunigung));
+	skillStartAntriebEffizienz = initTextFeld(200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->antriebEffizienz));
+	skillStartLaserIntensität = initTextFeld(200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->laserIntensität));
+	skillStartLaserEffizienz = initTextFeld(200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->laserEffizienz));
+	skillStartLaserTempo = initTextFeld(200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->laserTempo));
+	skillStartEnergieSchild = initTextFeld(200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->energieSchild));
+	skillStartEnergieSchildEffizienz = initTextFeld(200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->energieSchildEffizienz));
+	speichern = initKnopf(0, 380, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern");
+	this->daten = daten;
 }
 
 TeamTool::~TeamTool()
 {
-    teamAuswahl->release();
-    skillStartT->release();
-    skillStartStabilitätT->release();
-    skillStartEnergieT->release();
-    skillStartReparaturT->release();
-    skillStartAkkuT->release();
-    skillStartWendigkeitT->release();
-    skillStartBeschleunigungT->release();
-    skillStartAntriebEffizienzT->release();
-    skillStartLaserIntensitätT->release();
-    skillStartLaserEffizienzT->release();
-    skillStartLaserTempoT->release();
-    skillStartEnergieSchildT->release();
-    skillStartEnergieSchildEffizienzT->release();
-    skillStartStabilität->release();
-    skillStartEnergie->release();
-    skillStartReparatur->release();
-    skillStartAkku->release();
-    skillStartWendigkeit->release();
-    skillStartBeschleunigung->release();
-    skillStartAntriebEffizienz->release();
-    skillStartLaserIntensität->release();
-    skillStartLaserEffizienz->release();
-    skillStartLaserTempo->release();
-    skillStartEnergieSchild->release();
-    skillStartEnergieSchildEffizienz->release();
-    speichern->release();
-    daten->release();
+	teamAuswahl->release();
+	skillStartT->release();
+	skillStartStabilitätT->release();
+	skillStartEnergieT->release();
+	skillStartReparaturT->release();
+	skillStartAkkuT->release();
+	skillStartWendigkeitT->release();
+	skillStartBeschleunigungT->release();
+	skillStartAntriebEffizienzT->release();
+	skillStartLaserIntensitätT->release();
+	skillStartLaserEffizienzT->release();
+	skillStartLaserTempoT->release();
+	skillStartEnergieSchildT->release();
+	skillStartEnergieSchildEffizienzT->release();
+	skillStartStabilität->release();
+	skillStartEnergie->release();
+	skillStartReparatur->release();
+	skillStartAkku->release();
+	skillStartWendigkeit->release();
+	skillStartBeschleunigung->release();
+	skillStartAntriebEffizienz->release();
+	skillStartLaserIntensität->release();
+	skillStartLaserEffizienz->release();
+	skillStartLaserTempo->release();
+	skillStartEnergieSchild->release();
+	skillStartEnergieSchildEffizienz->release();
+	speichern->release();
+	daten->release();
 }
 
-void TeamTool::doPublicMausEreignis( MausEreignis &me )
+void TeamTool::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        me.verarbeitet = 1;
-    me.mx -= pos.x;
-    me.my -= pos.y;
-    teamAuswahl->doPublicMausEreignis( me );
-    skillStartT->doPublicMausEreignis( me );
-    skillStartStabilitätT->doPublicMausEreignis( me );
-    skillStartEnergieT->doPublicMausEreignis( me );
-    skillStartReparaturT->doPublicMausEreignis( me );
-    skillStartAkkuT->doPublicMausEreignis( me );
-    skillStartWendigkeitT->doPublicMausEreignis( me );
-    skillStartBeschleunigungT->doPublicMausEreignis( me );
-    skillStartAntriebEffizienzT->doPublicMausEreignis( me );
-    skillStartLaserIntensitätT->doPublicMausEreignis( me );
-    skillStartLaserEffizienzT->doPublicMausEreignis( me );
-    skillStartLaserTempoT->doPublicMausEreignis( me );
-    skillStartEnergieSchildT->doPublicMausEreignis( me );
-    skillStartEnergieSchildEffizienzT->doPublicMausEreignis( me );
-    skillStartStabilität->doPublicMausEreignis( me );
-    skillStartEnergie->doPublicMausEreignis( me );
-    skillStartReparatur->doPublicMausEreignis( me );
-    skillStartAkku->doPublicMausEreignis( me );
-    skillStartWendigkeit->doPublicMausEreignis( me );
-    skillStartBeschleunigung->doPublicMausEreignis( me );
-    skillStartAntriebEffizienz->doPublicMausEreignis( me );
-    skillStartLaserIntensität->doPublicMausEreignis( me );
-    skillStartLaserEffizienz->doPublicMausEreignis( me );
-    skillStartLaserTempo->doPublicMausEreignis( me );
-    skillStartEnergieSchild->doPublicMausEreignis( me );
-    skillStartEnergieSchildEffizienz->doPublicMausEreignis( me );
-    bool verarbeitet = me.verarbeitet;
-    speichern->doPublicMausEreignis( me );
-    if( !verarbeitet && me.verarbeitet && me.id == ME_RLinks )
-    {
-        TeamDaten *data = daten->getTeam( daten->getTeamIndexById( teamAuswahl->getAuswahl() + 1 ) );
-        data->maxStabilität = *skillStartStabilität->zText();
-        data->maxEnergie = *skillStartEnergie->zText();
-        data->reparatur = *skillStartReparatur->zText();
-        data->akkuLeistung = *skillStartAkku->zText();
-        data->wendigkeit = *skillStartWendigkeit->zText();
-        data->beschleunigung = *skillStartBeschleunigung->zText();
-        data->antriebEffizienz = *skillStartAntriebEffizienz->zText();
-        data->laserIntensität = *skillStartLaserIntensität->zText();
-        data->laserEffizienz = *skillStartLaserEffizienz->zText();
-        data->laserTempo = *skillStartLaserTempo->zText();
-        data->energieSchild = *skillStartEnergieSchild->zText();
-        data->energieSchildEffizienz = *skillStartEnergieSchildEffizienz->zText();
-        data->update();
-    }
-    me.mx += pos.x;
-    me.my += pos.y;
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        me.verarbeitet = vera;
+	bool vera = me.verarbeitet;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		me.verarbeitet = 1;
+	me.mx -= pos.x;
+	me.my -= pos.y;
+	teamAuswahl->doPublicMausEreignis(me);
+	skillStartT->doPublicMausEreignis(me);
+	skillStartStabilitätT->doPublicMausEreignis(me);
+	skillStartEnergieT->doPublicMausEreignis(me);
+	skillStartReparaturT->doPublicMausEreignis(me);
+	skillStartAkkuT->doPublicMausEreignis(me);
+	skillStartWendigkeitT->doPublicMausEreignis(me);
+	skillStartBeschleunigungT->doPublicMausEreignis(me);
+	skillStartAntriebEffizienzT->doPublicMausEreignis(me);
+	skillStartLaserIntensitätT->doPublicMausEreignis(me);
+	skillStartLaserEffizienzT->doPublicMausEreignis(me);
+	skillStartLaserTempoT->doPublicMausEreignis(me);
+	skillStartEnergieSchildT->doPublicMausEreignis(me);
+	skillStartEnergieSchildEffizienzT->doPublicMausEreignis(me);
+	skillStartStabilität->doPublicMausEreignis(me);
+	skillStartEnergie->doPublicMausEreignis(me);
+	skillStartReparatur->doPublicMausEreignis(me);
+	skillStartAkku->doPublicMausEreignis(me);
+	skillStartWendigkeit->doPublicMausEreignis(me);
+	skillStartBeschleunigung->doPublicMausEreignis(me);
+	skillStartAntriebEffizienz->doPublicMausEreignis(me);
+	skillStartLaserIntensität->doPublicMausEreignis(me);
+	skillStartLaserEffizienz->doPublicMausEreignis(me);
+	skillStartLaserTempo->doPublicMausEreignis(me);
+	skillStartEnergieSchild->doPublicMausEreignis(me);
+	skillStartEnergieSchildEffizienz->doPublicMausEreignis(me);
+	bool verarbeitet = me.verarbeitet;
+	speichern->doPublicMausEreignis(me);
+	if (!verarbeitet && me.verarbeitet && me.id == ME_RLinks)
+	{
+		TeamDaten* data = daten->getTeam(daten->getTeamIndexById(teamAuswahl->getAuswahl() + 1));
+		data->maxStabilität = (int)*skillStartStabilität->zText();
+		data->maxEnergie = (int)*skillStartEnergie->zText();
+		data->reparatur = (double)*skillStartReparatur->zText();
+		data->akkuLeistung = (double)*skillStartAkku->zText();
+		data->wendigkeit = (double)*skillStartWendigkeit->zText();
+		data->beschleunigung = (double)*skillStartBeschleunigung->zText();
+		data->antriebEffizienz = (double)*skillStartAntriebEffizienz->zText();
+		data->laserIntensität = (int)*skillStartLaserIntensität->zText();
+		data->laserEffizienz = (int)*skillStartLaserEffizienz->zText();
+		data->laserTempo = (int)*skillStartLaserTempo->zText();
+		data->energieSchild = (double)*skillStartEnergieSchild->zText();
+		data->energieSchildEffizienz = (double)*skillStartEnergieSchildEffizienz->zText();
+		data->update();
+	}
+	me.mx += pos.x;
+	me.my += pos.y;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		me.verarbeitet = vera;
 }
 
-void TeamTool::doTastaturEreignis( TastaturEreignis &te )
+void TeamTool::doTastaturEreignis(TastaturEreignis& te)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return;
-    teamAuswahl->doTastaturEreignis( te );
-    skillStartT->doTastaturEreignis( te );
-    skillStartStabilitätT->doTastaturEreignis( te );
-    skillStartEnergieT->doTastaturEreignis( te );
-    skillStartReparaturT->doTastaturEreignis( te );
-    skillStartAkkuT->doTastaturEreignis( te );
-    skillStartWendigkeitT->doTastaturEreignis( te );
-    skillStartBeschleunigungT->doTastaturEreignis( te );
-    skillStartAntriebEffizienzT->doTastaturEreignis( te );
-    skillStartLaserIntensitätT->doTastaturEreignis( te );
-    skillStartLaserEffizienzT->doTastaturEreignis( te );
-    skillStartLaserTempoT->doTastaturEreignis( te );
-    skillStartEnergieSchildT->doTastaturEreignis( te );
-    skillStartEnergieSchildEffizienzT->doTastaturEreignis( te );
-    skillStartStabilität->doTastaturEreignis( te );
-    skillStartEnergie->doTastaturEreignis( te );
-    skillStartReparatur->doTastaturEreignis( te );
-    skillStartAkku->doTastaturEreignis( te );
-    skillStartWendigkeit->doTastaturEreignis( te );
-    skillStartBeschleunigung->doTastaturEreignis( te );
-    skillStartAntriebEffizienz->doTastaturEreignis( te );
-    skillStartLaserIntensität->doTastaturEreignis( te );
-    skillStartLaserEffizienz->doTastaturEreignis( te );
-    skillStartLaserTempo->doTastaturEreignis( te );
-    skillStartEnergieSchild->doTastaturEreignis( te );
-    skillStartEnergieSchildEffizienz->doTastaturEreignis( te );
-    speichern->doTastaturEreignis( te );
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return;
+	teamAuswahl->doTastaturEreignis(te);
+	skillStartT->doTastaturEreignis(te);
+	skillStartStabilitätT->doTastaturEreignis(te);
+	skillStartEnergieT->doTastaturEreignis(te);
+	skillStartReparaturT->doTastaturEreignis(te);
+	skillStartAkkuT->doTastaturEreignis(te);
+	skillStartWendigkeitT->doTastaturEreignis(te);
+	skillStartBeschleunigungT->doTastaturEreignis(te);
+	skillStartAntriebEffizienzT->doTastaturEreignis(te);
+	skillStartLaserIntensitätT->doTastaturEreignis(te);
+	skillStartLaserEffizienzT->doTastaturEreignis(te);
+	skillStartLaserTempoT->doTastaturEreignis(te);
+	skillStartEnergieSchildT->doTastaturEreignis(te);
+	skillStartEnergieSchildEffizienzT->doTastaturEreignis(te);
+	skillStartStabilität->doTastaturEreignis(te);
+	skillStartEnergie->doTastaturEreignis(te);
+	skillStartReparatur->doTastaturEreignis(te);
+	skillStartAkku->doTastaturEreignis(te);
+	skillStartWendigkeit->doTastaturEreignis(te);
+	skillStartBeschleunigung->doTastaturEreignis(te);
+	skillStartAntriebEffizienz->doTastaturEreignis(te);
+	skillStartLaserIntensität->doTastaturEreignis(te);
+	skillStartLaserEffizienz->doTastaturEreignis(te);
+	skillStartLaserTempo->doTastaturEreignis(te);
+	skillStartEnergieSchild->doTastaturEreignis(te);
+	skillStartEnergieSchildEffizienz->doTastaturEreignis(te);
+	speichern->doTastaturEreignis(te);
 }
 
-bool TeamTool::tick( double tickVal )
+bool TeamTool::tick(double tickVal)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return __super::tick( tickVal );
-    bool ret = __super::tick( tickVal );
-    ret |= teamAuswahl->tick( tickVal );
-    ret |= skillStartT->tick( tickVal );
-    ret |= skillStartStabilitätT->tick( tickVal );
-    ret |= skillStartEnergieT->tick( tickVal );
-    ret |= skillStartReparaturT->tick( tickVal );
-    ret |= skillStartAkkuT->tick( tickVal );
-    ret |= skillStartWendigkeitT->tick( tickVal );
-    ret |= skillStartBeschleunigungT->tick( tickVal );
-    ret |= skillStartAntriebEffizienzT->tick( tickVal );
-    ret |= skillStartLaserIntensitätT->tick( tickVal );
-    ret |= skillStartLaserEffizienzT->tick( tickVal );
-    ret |= skillStartLaserTempoT->tick( tickVal );
-    ret |= skillStartEnergieSchildT->tick( tickVal );
-    ret |= skillStartEnergieSchildEffizienzT->tick( tickVal );
-    ret |= skillStartStabilität->tick( tickVal );
-    ret |= skillStartEnergie->tick( tickVal );
-    ret |= skillStartReparatur->tick( tickVal );
-    ret |= skillStartAkku->tick( tickVal );
-    ret |= skillStartWendigkeit->tick( tickVal );
-    ret |= skillStartBeschleunigung->tick( tickVal );
-    ret |= skillStartAntriebEffizienz->tick( tickVal );
-    ret |= skillStartLaserIntensität->tick( tickVal );
-    ret |= skillStartLaserEffizienz->tick( tickVal );
-    ret |= skillStartLaserTempo->tick( tickVal );
-    ret |= skillStartEnergieSchild->tick( tickVal );
-    ret |= skillStartEnergieSchildEffizienz->tick( tickVal );
-    ret |= speichern->tick( tickVal );
-    return ret;
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return __super::tick(tickVal);
+	bool ret = __super::tick(tickVal);
+	ret |= teamAuswahl->tick(tickVal);
+	ret |= skillStartT->tick(tickVal);
+	ret |= skillStartStabilitätT->tick(tickVal);
+	ret |= skillStartEnergieT->tick(tickVal);
+	ret |= skillStartReparaturT->tick(tickVal);
+	ret |= skillStartAkkuT->tick(tickVal);
+	ret |= skillStartWendigkeitT->tick(tickVal);
+	ret |= skillStartBeschleunigungT->tick(tickVal);
+	ret |= skillStartAntriebEffizienzT->tick(tickVal);
+	ret |= skillStartLaserIntensitätT->tick(tickVal);
+	ret |= skillStartLaserEffizienzT->tick(tickVal);
+	ret |= skillStartLaserTempoT->tick(tickVal);
+	ret |= skillStartEnergieSchildT->tick(tickVal);
+	ret |= skillStartEnergieSchildEffizienzT->tick(tickVal);
+	ret |= skillStartStabilität->tick(tickVal);
+	ret |= skillStartEnergie->tick(tickVal);
+	ret |= skillStartReparatur->tick(tickVal);
+	ret |= skillStartAkku->tick(tickVal);
+	ret |= skillStartWendigkeit->tick(tickVal);
+	ret |= skillStartBeschleunigung->tick(tickVal);
+	ret |= skillStartAntriebEffizienz->tick(tickVal);
+	ret |= skillStartLaserIntensität->tick(tickVal);
+	ret |= skillStartLaserEffizienz->tick(tickVal);
+	ret |= skillStartLaserTempo->tick(tickVal);
+	ret |= skillStartEnergieSchild->tick(tickVal);
+	ret |= skillStartEnergieSchildEffizienz->tick(tickVal);
+	ret |= speichern->tick(tickVal);
+	return ret;
 }
 
-void TeamTool::render( Bild &rObj )
+void TeamTool::render(Bild& rObj)
 {
-    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
-        return;
-    if( rObj.setDrawOptions( pos, gr ) )
-    {
-        skillStartT->render( rObj );
-        skillStartStabilitätT->render( rObj );
-        skillStartEnergieT->render( rObj );
-        skillStartReparaturT->render( rObj );
-        skillStartAkkuT->render( rObj );
-        skillStartWendigkeitT->render( rObj );
-        skillStartBeschleunigungT->render( rObj );
-        skillStartAntriebEffizienzT->render( rObj );
-        skillStartLaserIntensitätT->render( rObj );
-        skillStartLaserEffizienzT->render( rObj );
-        skillStartLaserTempoT->render( rObj );
-        skillStartEnergieSchildT->render( rObj );
-        skillStartEnergieSchildEffizienzT->render( rObj );
-        skillStartStabilität->render( rObj );
-        skillStartEnergie->render( rObj );
-        skillStartReparatur->render( rObj );
-        skillStartAkku->render( rObj );
-        skillStartWendigkeit->render( rObj );
-        skillStartBeschleunigung->render( rObj );
-        skillStartAntriebEffizienz->render( rObj );
-        skillStartLaserIntensität->render( rObj );
-        skillStartLaserEffizienz->render( rObj );
-        skillStartLaserTempo->render( rObj );
-        skillStartEnergieSchild->render( rObj );
-        skillStartEnergieSchildEffizienz->render( rObj );
-        speichern->render( rObj );
-        teamAuswahl->render( rObj );
-        rObj.releaseDrawOptions();
-    }
+	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
+		return;
+	if (rObj.setDrawOptions(pos, gr))
+	{
+		skillStartT->render(rObj);
+		skillStartStabilitätT->render(rObj);
+		skillStartEnergieT->render(rObj);
+		skillStartReparaturT->render(rObj);
+		skillStartAkkuT->render(rObj);
+		skillStartWendigkeitT->render(rObj);
+		skillStartBeschleunigungT->render(rObj);
+		skillStartAntriebEffizienzT->render(rObj);
+		skillStartLaserIntensitätT->render(rObj);
+		skillStartLaserEffizienzT->render(rObj);
+		skillStartLaserTempoT->render(rObj);
+		skillStartEnergieSchildT->render(rObj);
+		skillStartEnergieSchildEffizienzT->render(rObj);
+		skillStartStabilität->render(rObj);
+		skillStartEnergie->render(rObj);
+		skillStartReparatur->render(rObj);
+		skillStartAkku->render(rObj);
+		skillStartWendigkeit->render(rObj);
+		skillStartBeschleunigung->render(rObj);
+		skillStartAntriebEffizienz->render(rObj);
+		skillStartLaserIntensität->render(rObj);
+		skillStartLaserEffizienz->render(rObj);
+		skillStartLaserTempo->render(rObj);
+		skillStartEnergieSchild->render(rObj);
+		skillStartEnergieSchildEffizienz->render(rObj);
+		speichern->render(rObj);
+		teamAuswahl->render(rObj);
+		rObj.releaseDrawOptions();
+	}
 }
 
-void TeamTool::selectTeam( int id )
+void TeamTool::selectTeam(int id)
 {
-    int index = daten->getTeamIndexById( id );
-    teamAuswahl->setAuswahl( id - 1 );
-    TeamDaten *Team = daten->getTeam( index );
-    skillStartStabilität->setText( Text( Team->maxStabilität ) );
-    skillStartEnergie->setText( Text( Team->maxEnergie ) );
-    skillStartReparatur->setText( Text( Team->reparatur ) );
-    skillStartAkku->setText( Text( Team->akkuLeistung ) );
-    skillStartWendigkeit->setText( Text( Team->wendigkeit ) );
-    skillStartBeschleunigung->setText( Text( Team->beschleunigung ) );
-    skillStartAntriebEffizienz->setText( Text( Team->antriebEffizienz ) );
-    skillStartLaserIntensität->setText( Text( Team->laserIntensität ) );
-    skillStartLaserEffizienz->setText( Text( Team->laserEffizienz ) );
-    skillStartLaserTempo->setText( Text( Team->laserTempo ) );
-    skillStartEnergieSchild->setText( Text( Team->energieSchild ) );
-    skillStartEnergieSchildEffizienz->setText( Text( Team->energieSchildEffizienz ) );
+	int index = daten->getTeamIndexById(id);
+	teamAuswahl->setAuswahl(id - 1);
+	TeamDaten* Team = daten->getTeam(index);
+	skillStartStabilität->setText(Text(Team->maxStabilität));
+	skillStartEnergie->setText(Text(Team->maxEnergie));
+	skillStartReparatur->setText(Text(Team->reparatur));
+	skillStartAkku->setText(Text(Team->akkuLeistung));
+	skillStartWendigkeit->setText(Text(Team->wendigkeit));
+	skillStartBeschleunigung->setText(Text(Team->beschleunigung));
+	skillStartAntriebEffizienz->setText(Text(Team->antriebEffizienz));
+	skillStartLaserIntensität->setText(Text(Team->laserIntensität));
+	skillStartLaserEffizienz->setText(Text(Team->laserEffizienz));
+	skillStartLaserTempo->setText(Text(Team->laserTempo));
+	skillStartEnergieSchild->setText(Text(Team->energieSchild));
+	skillStartEnergieSchildEffizienz->setText(Text(Team->energieSchildEffizienz));
 }

Asteroids/Editor/Karte/EditorKarte.cpp

@@ -12,58 +12,58 @@ using namespace Editor;
 
 
 SpielerDaten::SpielerDaten()
-    : Model()
+	: Model()
 {}
 
-SpielerDaten::SpielerDaten( const SpielerDaten& daten )
+SpielerDaten::SpielerDaten(const SpielerDaten& daten)
 {
-    *this = daten;
-    views->getThis();
+	*this = daten;
+	views->getThis();
 }
 
 
 TeamDaten::TeamDaten()
-    : Model()
+	: Model()
 {}
 
-TeamDaten::TeamDaten( const TeamDaten& daten )
+TeamDaten::TeamDaten(const TeamDaten& daten)
 {
-    *this = daten;
-    views->getThis();
+	*this = daten;
+	views->getThis();
 }
 
 
 ObjektDaten::ObjektDaten()
-    : Model()
+	: Model()
 {}
 
-ObjektDaten::ObjektDaten( const ObjektDaten& daten )
+ObjektDaten::ObjektDaten(const ObjektDaten& daten)
 {
-    *this = daten;
-    views->getThis();
+	*this = daten;
+	views->getThis();
 }
 
 
-EditorObject::EditorObject( EditorObject::ObjektTyp typ, int id )
-    : Model2DObject()
+EditorObject::EditorObject(EditorObject::ObjektTyp typ, int id)
+	: Model2DObject()
 {
-    this->typ = typ;
-    this->id = id;
+	this->typ = typ;
+	this->id = id;
 }
 
 EditorObject::~EditorObject()
 {}
 
-bool EditorObject::isObjekt( EditorObject::ObjektTyp typ, int id )
+bool EditorObject::isObjekt(EditorObject::ObjektTyp typ, int id)
 {
-    return this->typ == typ && this->id == id;
+	return this->typ == typ && this->id == id;
 }
 
 
-EdSpieler::EdSpieler( SpielerDaten* model )
-    : EditorObject( SPIELER, model->id )
+EdSpieler::EdSpieler(SpielerDaten* model)
+	: EditorObject(SPIELER, model->id)
 {
-    mdl = model;
+	mdl = model;
 }
 
 EdSpieler::~EdSpieler()
@@ -71,16 +71,16 @@ EdSpieler::~EdSpieler()
 
 void EdSpieler::update()
 {
-    mdl->pos = position;
-    mdl->rot = (double)rotation;
-    mdl->update();
+	mdl->pos = position;
+	mdl->rot = (double)rotation;
+	mdl->update();
 }
 
 
-EdObjekt::EdObjekt( ObjektDaten* model )
-    : EditorObject( OBJEKT, model->id )
+EdObjekt::EdObjekt(ObjektDaten* model)
+	: EditorObject(OBJEKT, model->id)
 {
-    mdl = model;
+	mdl = model;
 }
 
 EdObjekt::~EdObjekt()
@@ -88,594 +88,608 @@ EdObjekt::~EdObjekt()
 
 void EdObjekt::update()
 {
-    mdl->pos = position;
-    mdl->rot = rotation;
-    mdl->scale = size;
-    mdl->update();
-}
-
-
-UpdateObserver::UpdateObserver( std::function< void() > f )
-{
-    this->f = f;
-}
-
-void UpdateObserver::update( Model* m )
-{
-    f();
-}
-
-
-KarteDaten::KarteDaten( EditorKlient* client, SpielerTeamStruktur* sts )
-    : Thread()
-{
-    HMODULE dll = Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
-    getGSLDatei = (GetGSLDatei)GetProcAddress( dll, "getGSLDatei" );
-    welt = new Welt2D();
-    welt->setCircular( 1 );
-    this->client = client;
-    this->sts = (SpielerTeamStruktur*)sts->getThis();
-    client->loadMapSize( size );
-    client->loadResources( resources );
-    client->loadSpieler( spieler );
-    client->loadTeams( teams );
-    client->loadObjekte( objekte );
-    welt->setSize( size.x, size.y );
-    welt->setSize( 1 );
-    for( auto s : spieler )
-    {
-        Model2DObject* model = new EdSpieler( s );
-        Bild* bild;
-        int fc = sts->spielerFarbe->get( s->id - 1 );
-        for( auto r : resources )
-        {
-            if( r->id == s->m2d )
-                model->setModel( client->loadModel( r->path ) );
-            if( r->id == s->bild )
-                bild = client->loadBild( r->path );
-        }
-        if( bild )
-        {
-            Bild* shb = new Bild();
-            shb->neuBild( bild->getBreite(), bild->getHeight(), 0 );
-            int maxP = shb->getBreite() * shb->getHeight();
-            int* buffer = bild->getBuffer();
-            for( int i = 0; i < maxP; i++ )
-            {
-                if( buffer[ i ] )
-                {
-                    shb->setPixelDP( i, fc );
-                    shb->alphaPixelDP2D( i, buffer[ i ] );
-                }
-            }
-            Textur2D* textur = new Textur2D();
-            textur->setTexturZ( shb );
-            model->setTextur( textur, "ship" );
-            bild->release();
-        }
-        model->setPosition( s->pos );
-        model->setDrehung( (float)s->rot );
-        model->setCollision( 0 );
-        welt->addObject( model );
-        SpielerDaten* d = s;
-        d->addView( new UpdateObserver( [this, d]() {
-            aktionen.add( [this, d]() {
-                this->client->saveSpieler( d );
-            } );
-        } ) );
-    }
-    for( auto t : teams )
-    {
-        TeamDaten* d = t;
-        d->addView( new UpdateObserver( [this, d]() {
-            aktionen.add( [this, d]() {
-                this->client->saveTeam( d );
-            } );
-        } ) );
-    }
-    for( auto o : objekte )
-    {
-        Model2DObject* model = new EdObjekt( o );
-        Bild* bild;
-        for( auto r : resources )
-        {
-            if( r->id == o->m2d )
-                model->setModel( client->loadModel( r->path ) );
-            if( r->id == o->bild )
-                bild = client->loadBild( r->path );
-        }
-        if( bild )
-        {
-            Textur2D* textur = new Textur2D();
-            textur->setTexturZ( bild );
-            model->setTextur( textur );
-        }
-        model->setPosition( o->pos );
-        model->setDrehung( o->rot );
-        model->setSize( o->scale );
-        model->setCollision( 0 );
-        welt->addObject( model );
-        ObjektDaten* d = o;
-        d->addView( new UpdateObserver( [this, d, model]() {
-            aktionen.add( [this, d, model]() {
-                this->client->saveObjekt( d );
-                Bild* bild = 0;
-                Model2DData* da = 0;
-                for( auto r : resources )
-                {
-                    if( r->id == d->m2d )
-                        da = this->client->loadModel( r->path );
-                    if( r->id == d->bild )
-                        bild = this->client->loadBild( r->path );
-                }
-                if( bild && da )
-                {
-                    Textur2D* textur = new Textur2D();
-                    textur->setTexturZ( bild );
-                    model->postAction( [model, da, textur]() {
-                        model->setModel( da );
-                        model->setTextur( textur );
-                    } );
-                }
-                else
-                {
-                    if( bild )
-                        bild->release();
-                    if( da )
-                        da->release();
-                }
-            } );
-        } ) );
-    }
-    exit = 0;
-    start();
+	mdl->pos = position;
+	mdl->rot = rotation;
+	mdl->scale = size;
+	mdl->update();
+}
+
+
+UpdateObserver::UpdateObserver(std::function< void() > f)
+{
+	this->f = f;
+}
+
+void UpdateObserver::update(Model* m)
+{
+	f();
+}
+
+
+KarteDaten::KarteDaten(EditorKlient* client, SpielerTeamStruktur* sts)
+	: Thread()
+{
+	HMODULE dll = Framework::getDLLRegister()->ladeDLL("GSL.dll", "data/bin/GSL.dll");
+	getGSLDatei = (GetGSLDatei)GetProcAddress(dll, "getGSLDatei");
+	welt = new Welt2D();
+	welt->setCircular(1);
+	this->client = client;
+	this->sts = (SpielerTeamStruktur*)sts->getThis();
+	client->loadMapSize(size);
+	client->loadResources(resources);
+	client->loadSpieler(spieler);
+	client->loadTeams(teams);
+	client->loadObjekte(objekte);
+	welt->setSize(size.x, size.y);
+	welt->setSize(1);
+	for (auto s : spieler)
+	{
+		Model2DObject* model = new EdSpieler(s);
+		Bild* bild;
+		int fc = sts->spielerFarbe->get(s->id - 1);
+		for (auto r : resources)
+		{
+			if (r->id == s->m2d)
+				model->setModel(client->loadModel(r->path));
+			if (r->id == s->bild)
+				bild = client->loadBild(r->path);
+		}
+		if (bild)
+		{
+			Bild* shb = new Bild();
+			shb->neuBild(bild->getBreite(), bild->getHeight(), 0);
+			int maxP = shb->getBreite() * shb->getHeight();
+			int* buffer = bild->getBuffer();
+			for (int i = 0; i < maxP; i++)
+			{
+				if (buffer[i])
+				{
+					shb->setPixelDP(i, fc);
+					shb->alphaPixelDP2D(i, buffer[i]);
+				}
+			}
+			Textur2D* textur = new Textur2D();
+			textur->setTexturZ(shb);
+			model->setTextur(textur, "ship");
+			bild->release();
+		}
+		model->setPosition(s->pos);
+		model->setDrehung((float)s->rot);
+		model->setCollision(0);
+		welt->addObject(model);
+		SpielerDaten* d = s;
+		d->addView(new UpdateObserver([this, d]()
+			{
+				aktionen.add([this, d]()
+					{
+						this->client->saveSpieler(d);
+					});
+			}));
+	}
+	for (auto t : teams)
+	{
+		TeamDaten* d = t;
+		d->addView(new UpdateObserver([this, d]()
+			{
+				aktionen.add([this, d]()
+					{
+						this->client->saveTeam(d);
+					});
+			}));
+	}
+	for (auto o : objekte)
+	{
+		Model2DObject* model = new EdObjekt(o);
+		Bild* bild;
+		for (auto r : resources)
+		{
+			if (r->id == o->m2d)
+				model->setModel(client->loadModel(r->path));
+			if (r->id == o->bild)
+				bild = client->loadBild(r->path);
+		}
+		if (bild)
+		{
+			Textur2D* textur = new Textur2D();
+			textur->setTexturZ(bild);
+			model->setTextur(textur);
+		}
+		model->setPosition(o->pos);
+		model->setDrehung(o->rot);
+		model->setSize(o->scale);
+		model->setCollision(0);
+		welt->addObject(model);
+		ObjektDaten* d = o;
+		d->addView(new UpdateObserver([this, d, model]()
+			{
+				aktionen.add([this, d, model]()
+					{
+						this->client->saveObjekt(d);
+						Bild* bild = 0;
+						Model2DData* da = 0;
+						for (auto r : resources)
+						{
+							if (r->id == d->m2d)
+								da = this->client->loadModel(r->path);
+							if (r->id == d->bild)
+								bild = this->client->loadBild(r->path);
+						}
+						if (bild && da)
+						{
+							Textur2D* textur = new Textur2D();
+							textur->setTexturZ(bild);
+							model->postAction([model, da, textur]()
+								{
+									model->setModel(da);
+									model->setTextur(textur);
+								});
+						}
+						else
+						{
+							if (bild)
+								bild->release();
+							if (da)
+								da->release();
+						}
+					});
+			}));
+	}
+	exit = 0;
+	start();
 }
 
 KarteDaten::~KarteDaten()
 {
-    cs.lock();
-    for( auto i : resources )
-        delete i;
-    for( auto i : objekte )
-        delete i;
-    for( auto i : spieler )
-        delete i;
-    for( auto i : teams )
-        delete i;
-    sts->release();
-    client->release();
-    welt->release();
-    Framework::getDLLRegister()->releaseDLL( "GSL.dll" );
-    cs.unlock();
-}
-
-void KarteDaten::addObjekt( ObjektDaten& daten, std::function< void( int ) > callBack )
-{
-    ObjektDaten* nd = new ObjektDaten( daten );
-    cs.lock();
-    nd->id = 0;
-    bool found = 0;
-    do
-    {
-        nd->id++;
-        found = 0;
-        for( auto o : objekte )
-        {
-            if( o->id == nd->id )
-            {
-                found = 1;
-                break;
-            }
-        }
-    } while( found );
-    objekte.add( nd );
-    Model2DObject* model = new EdObjekt( nd );
-    Bild* bild;
-    for( auto r : resources )
-    {
-        if( r->id == nd->m2d )
-            model->setModel( client->loadModel( r->path ) );
-        if( r->id == nd->bild )
-            bild = client->loadBild( r->path );
-    }
-    if( bild )
-    {
-        Textur2D* textur = new Textur2D();
-        textur->setTexturZ( bild );
-        model->setTextur( textur );
-    }
-    model->setPosition( nd->pos );
-    model->setDrehung( nd->rot );
-    model->setSize( nd->scale );
-    model->setCollision( 0 );
-    welt->addObject( model );
-    nd->addView( new UpdateObserver( [this, nd, model]() {
-        aktionen.add( [this, nd, model]() {
-            this->client->saveObjekt( nd );
-            Bild* bild = 0;
-            Model2DData* d = 0;
-            for( auto r : resources )
-            {
-                if( r->id == nd->m2d )
-                    d = this->client->loadModel( r->path );
-                if( r->id == nd->bild )
-                    bild = this->client->loadBild( r->path );
-            }
-            if( bild && d )
-            {
-                Textur2D* textur = new Textur2D();
-                textur->setTexturZ( bild );
-                model->postAction( [model, d, textur]() {
-                    model->setModel( d );
-                    model->setTextur( textur );
-                } );
-            }
-            else
-            {
-                if( bild )
-                    bild->release();
-                if( d )
-                    d->release();
-            }
-        } );
-    } ) );
-    EditorKlient* c = client;
-    aktionen.add( [nd, c, callBack]() {
-        if( c->saveObjekt( nd ) )
-            callBack( nd->id );
-        else
-            callBack( 0 );
-    } );
-    cs.unlock();
-}
-
-void KarteDaten::removeObjekt( int index )
-{
-    cs.lock();
-    int id = objekte.get( index )->id;
-    EditorObject* obj = 0;
-    for( auto o = welt->getMembers(); o; o++ )
-    {
-        obj = (EditorObject*)o._;
-        if( obj->isObjekt( EditorObject::OBJEKT, id ) )
-            break;
-    }
-    welt->removeObject( obj );
-    delete objekte.get( index );
-    objekte.remove( index );
-    EditorKlient* c = client;
-    aktionen.add( [id, c]() {
-        c->deleteObjekt( id );
-    } );
-    cs.unlock();
+	cs.lock();
+	for (auto i : resources)
+		delete i;
+	for (auto i : objekte)
+		delete i;
+	for (auto i : spieler)
+		delete i;
+	for (auto i : teams)
+		delete i;
+	sts->release();
+	client->release();
+	welt->release();
+	Framework::getDLLRegister()->releaseDLL("GSL.dll");
+	cs.unlock();
+}
+
+void KarteDaten::addObjekt(ObjektDaten& daten, std::function< void(int) > callBack)
+{
+	ObjektDaten* nd = new ObjektDaten(daten);
+	cs.lock();
+	nd->id = 0;
+	bool found = 0;
+	do
+	{
+		nd->id++;
+		found = 0;
+		for (auto o : objekte)
+		{
+			if (o->id == nd->id)
+			{
+				found = 1;
+				break;
+			}
+		}
+	} while (found);
+	objekte.add(nd);
+	Model2DObject* model = new EdObjekt(nd);
+	Bild* bild;
+	for (auto r : resources)
+	{
+		if (r->id == nd->m2d)
+			model->setModel(client->loadModel(r->path));
+		if (r->id == nd->bild)
+			bild = client->loadBild(r->path);
+	}
+	if (bild)
+	{
+		Textur2D* textur = new Textur2D();
+		textur->setTexturZ(bild);
+		model->setTextur(textur);
+	}
+	model->setPosition(nd->pos);
+	model->setDrehung(nd->rot);
+	model->setSize(nd->scale);
+	model->setCollision(0);
+	welt->addObject(model);
+	nd->addView(new UpdateObserver([this, nd, model]()
+		{
+			aktionen.add([this, nd, model]()
+				{
+					this->client->saveObjekt(nd);
+					Bild* bild = 0;
+					Model2DData* d = 0;
+					for (auto r : resources)
+					{
+						if (r->id == nd->m2d)
+							d = this->client->loadModel(r->path);
+						if (r->id == nd->bild)
+							bild = this->client->loadBild(r->path);
+					}
+					if (bild && d)
+					{
+						Textur2D* textur = new Textur2D();
+						textur->setTexturZ(bild);
+						model->postAction([model, d, textur]()
+							{
+								model->setModel(d);
+								model->setTextur(textur);
+							});
+					}
+					else
+					{
+						if (bild)
+							bild->release();
+						if (d)
+							d->release();
+					}
+				});
+		}));
+	EditorKlient* c = client;
+	aktionen.add([nd, c, callBack]()
+		{
+			if (c->saveObjekt(nd))
+				callBack(nd->id);
+			else
+				callBack(0);
+		});
+	cs.unlock();
+}
+
+void KarteDaten::removeObjekt(int index)
+{
+	cs.lock();
+	int id = objekte.get(index)->id;
+	EditorObject* obj = 0;
+	for (auto o = welt->getMembers(); o; o++)
+	{
+		obj = (EditorObject*)o._;
+		if (obj->isObjekt(EditorObject::OBJEKT, id))
+			break;
+	}
+	welt->removeObject(obj);
+	delete objekte.get(index);
+	objekte.remove(index);
+	EditorKlient* c = client;
+	aktionen.add([id, c]()
+		{
+			c->deleteObjekt(id);
+		});
+	cs.unlock();
 }
 
 void KarteDaten::thread()
 {
-    while( !exit )
-    {
-        cs.lock();
-        while( hasAktions() )
-        {
-            std::function< void() > ak = aktionen.get( 0 );
-            cs.unlock();
-            ak();
-            cs.lock();
-            aktionen.remove( 0 );
-        }
-        cs.unlock();
-        Sleep( 100 );
-    }
+	while (!exit)
+	{
+		cs.lock();
+		while (hasAktions())
+		{
+			std::function< void() > ak = aktionen.get(0);
+			cs.unlock();
+			ak();
+			cs.lock();
+			aktionen.remove(0);
+		}
+		cs.unlock();
+		Sleep(100);
+	}
 }
 
-ResourceDaten* KarteDaten::getResource( int index )
+ResourceDaten* KarteDaten::getResource(int index)
 {
-    ResourceDaten* ret = 0;
-    cs.lock();
-    ret = resources.get( index );
-    cs.unlock();
-    return ret;
+	ResourceDaten* ret = 0;
+	cs.lock();
+	ret = resources.get(index);
+	cs.unlock();
+	return ret;
 }
 
-ObjektDaten* KarteDaten::getObjekt( int index )
+ObjektDaten* KarteDaten::getObjekt(int index)
 {
-    ObjektDaten* ret = 0;
-    cs.lock();
-    ret = objekte.get( index );
-    cs.unlock();
-    return ret;
+	ObjektDaten* ret = 0;
+	cs.lock();
+	ret = objekte.get(index);
+	cs.unlock();
+	return ret;
 }
 
-SpielerDaten* KarteDaten::getSpieler( int index )
+SpielerDaten* KarteDaten::getSpieler(int index)
 {
-    SpielerDaten* ret = 0;
-    cs.lock();
-    ret = spieler.get( index );
-    cs.unlock();
-    return ret;
+	SpielerDaten* ret = 0;
+	cs.lock();
+	ret = spieler.get(index);
+	cs.unlock();
+	return ret;
 }
 
-TeamDaten* KarteDaten::getTeam( int index )
+TeamDaten* KarteDaten::getTeam(int index)
 {
-    TeamDaten* ret = 0;
-    cs.lock();
-    ret = teams.get( index );
-    cs.unlock();
-    return ret;
+	TeamDaten* ret = 0;
+	cs.lock();
+	ret = teams.get(index);
+	cs.unlock();
+	return ret;
 }
 
-const char* KarteDaten::getTeamName( int index )
+const char* KarteDaten::getTeamName(int index)
 {
-    return sts->teamName->z( teams.get( index )->id - 1 )->getText();
+	return sts->teamName->z(teams.get(index)->id - 1)->getText();
 }
 
-int KarteDaten::getSpielerIndexById( int id )
+int KarteDaten::getSpielerIndexById(int id)
 {
-    int index = 0;
-    cs.lock();
-    for( auto i : spieler )
-    {
-        if( i->id == id )
-            break;
-        index++;
-    }
-    cs.unlock();
-    return index;
+	int index = 0;
+	cs.lock();
+	for (auto i : spieler)
+	{
+		if (i->id == id)
+			break;
+		index++;
+	}
+	cs.unlock();
+	return index;
 }
 
 int KarteDaten::getSpielerAnzahl() const
 {
-    return spieler.getEintragAnzahl();
+	return spieler.getEintragAnzahl();
 }
 
-int KarteDaten::getTeamIndexById( int id )
+int KarteDaten::getTeamIndexById(int id)
 {
-    int index = 0;
-    cs.lock();
-    for( auto i : teams )
-    {
-        if( i->id == id )
-            break;
-        index++;
-    }
-    cs.unlock();
-    return index;
+	int index = 0;
+	cs.lock();
+	for (auto i : teams)
+	{
+		if (i->id == id)
+			break;
+		index++;
+	}
+	cs.unlock();
+	return index;
 }
 
 int KarteDaten::getTeamAnzahl() const
 {
-    return teams.getEintragAnzahl();
+	return teams.getEintragAnzahl();
 }
 
-int KarteDaten::getObjektIndexById( int id )
+int KarteDaten::getObjektIndexById(int id)
 {
-    int index = 0;
-    cs.lock();
-    for( auto i : objekte )
-    {
-        if( i->id == id )
-            break;
-        index++;
-    }
-    cs.unlock();
-    return index;
+	int index = 0;
+	cs.lock();
+	for (auto i : objekte)
+	{
+		if (i->id == id)
+			break;
+		index++;
+	}
+	cs.unlock();
+	return index;
 }
 
 int KarteDaten::getObjektAnzahl() const
 {
-    return objekte.getEintragAnzahl();
+	return objekte.getEintragAnzahl();
 }
 
-int KarteDaten::getResourceIndexById( int id )
+int KarteDaten::getResourceIndexById(int id)
 {
-    int index = 0;
-    cs.lock();
-    for( auto i : resources )
-    {
-        if( i->id == id )
-            break;
-        index++;
-    }
-    cs.unlock();
-    return index;
+	int index = 0;
+	cs.lock();
+	for (auto i : resources)
+	{
+		if (i->id == id)
+			break;
+		index++;
+	}
+	cs.unlock();
+	return index;
 }
 
 int KarteDaten::getResourceAnzahl()
 {
-    return resources.getEintragAnzahl();
+	return resources.getEintragAnzahl();
 }
 
 bool KarteDaten::hasError() const
 {
-    return !error.istGleich( "" );
+	return !error.istGleich("");
 }
 
-char* KarteDaten::getError() const
+const char* KarteDaten::getError() const
 {
-    return error;
+	return error;
 }
 
 bool KarteDaten::hasAktions() const
 {
-    return aktionen.getEintragAnzahl() > 0;
+	return aktionen.getEintragAnzahl() > 0;
 }
 
 Welt2D* KarteDaten::getWelt() const
 {
-    return dynamic_cast<Welt2D*>(welt->getThis());
+	return dynamic_cast<Welt2D*>(welt->getThis());
 }
 
 Welt2D* KarteDaten::zWelt() const
 {
-    return welt;
+	return welt;
 }
-
-void KarteDaten::getResourceIdFromPath( const char* path, std::function< void( int ) > callBack )
-{
-    for( auto r : resources )
-    {
-        if( r->path.istGleich( path ) )
-        {
-            callBack( r->id );
-            return;
-        }
-    }
-    aktionen.add( [this, path, callBack]() {
-        int id = client->addResource( path );
-        if( !id )
-        {
-            callBack( 0 );
-            return;
-        }
-        ResourceDaten* nr = new ResourceDaten();
-        nr->id = id;
-        nr->path = path;
-        cs.lock();
-        resources.add( nr );
-        cs.unlock();
-        callBack( id );
-    } );
-}
-
-bool KarteDaten::doesResourceExist( const char* path )
-{
-    for( auto r : resources )
-    {
-        if( r->path.istGleich( path ) )
-            return 1;
-    }
-    return 0;
-}
-
-Model2DData* KarteDaten::loadModelFromRessource( int id )
-{
-    for( auto r : resources )
-    {
-        if( r->id == id )
-            return client->loadModel( r->path );
-    }
-    return 0;
-}
-
-Bild* KarteDaten::loadBildFromRessource( int id )
-{
-    for( auto r : resources )
-    {
-        if( r->id == id )
-            return client->loadBild( r->path );
-    }
-    return 0;
-}
-
-Model2DData* KarteDaten::loadModelFromPath( const char* path )
-{
-    return client->loadModel( path );
-}
-
-Bild* KarteDaten::loadBildFromPath( const char* path )
-{
-    return client->loadBild( path );
-}
-
-void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text >* ) > callBack )
-{
-    cs.lock();
-    aktionen.add( [this, callBack]() {
-        RCArray< Text >* result = new RCArray< Text >();
-        loadSpielResourcePathsFromFolder( "data/spiele/Asteroids", result );
-        RCArray< Text >* mapPaths = client->getAllMapResourcePaths();
-        for( auto mp : *mapPaths )
-        {
-            if( !doesResourceExist( mp->getText() ) )
-                result->add( dynamic_cast<Text*>(mp->getThis()) );
-        }
-        mapPaths->release();
-        callBack( result );
-    } );
-    cs.unlock();
-}
-
-void KarteDaten::loadSpielResourcePathsFromFolder( const char* folderPath, RCArray< Text >* zPaths )
-{
-    Datei f;
-    f.setDatei( folderPath );
-    if( f.istOrdner() )
-    {
-        RCArray< Text >* list = f.getDateiListe();
-        for( auto n : *list )
-        {
-            Text path( folderPath );
-            path += Text( "/" ) + (const char*)n->getText();
-            loadSpielResourcePathsFromFolder( path, zPaths );
-        }
-        list->release();
-    }
-    else
-    {
-        if( f.zPfad()->hat( ".ltdb" ) )
-        {
-            LTDBDatei d;
-            d.setDatei( new Text( folderPath ) );
-            d.leseDaten( 0 );
-            int anz = d.getBildAnzahl();
-            for( int i = 0; i < anz; i++ )
-            {
-                Text* path = new Text( folderPath );
-                path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
-                path->append( (const char*)(Text( "/" ) + (const char*)d.zBildListe()->z( i )->getText()) );
-                if( doesResourceExist( path->getText() ) )
-                    path->release();
-                else
-                    zPaths->add( path );
-            }
-        }
-        if( f.zPfad()->hat( ".m2" ) )
-        {
-            M2Datei d;
-            d.setPfad( folderPath );
-            d.leseDaten();
-            int anz = d.getModelAnzahl();
-            for( int i = 0; i < anz; i++ )
-            {
-                Text* path = new Text( folderPath );
-                path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
-                path->append( (const char*)(Text( "/" ) + (const char*)d.zModelName( i )->getText()) );
-                if( doesResourceExist( path->getText() ) )
-                    path->release();
-                else
-                    zPaths->add( path );
-            }
-        }
-        if( f.zPfad()->hat( ".gsl" ) )
-        {
-            HMODULE dll = Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
-            GSL::GSLDateiV* d = getGSLDatei();
-            d->setDatei( (char*)folderPath );
-            d->leseDaten();
-            int anz = d->getSoundAnzahl();
-            for( int i = 0; i < anz; i++ )
-            {
-                Text* path = new Text( folderPath );
-                path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
-                Text* name = d->getSoundName( i );
-                path->append( (const char*)(Text( "/" ) + (const char*)name->getText()) );
-                name->release();
-                if( doesResourceExist( path->getText() ) )
-                    path->release();
-                else
-                    zPaths->add( path );
-            }
-        }
-    }
+
+void KarteDaten::getResourceIdFromPath(const char* path, std::function< void(int) > callBack)
+{
+	for (auto r : resources)
+	{
+		if (r->path.istGleich(path))
+		{
+			callBack(r->id);
+			return;
+		}
+	}
+	aktionen.add([this, path, callBack]()
+		{
+			int id = client->addResource(path);
+			if (!id)
+			{
+				callBack(0);
+				return;
+			}
+			ResourceDaten* nr = new ResourceDaten();
+			nr->id = id;
+			nr->path = path;
+			cs.lock();
+			resources.add(nr);
+			cs.unlock();
+			callBack(id);
+		});
+}
+
+bool KarteDaten::doesResourceExist(const char* path)
+{
+	for (auto r : resources)
+	{
+		if (r->path.istGleich(path))
+			return 1;
+	}
+	return 0;
+}
+
+Model2DData* KarteDaten::loadModelFromRessource(int id)
+{
+	for (auto r : resources)
+	{
+		if (r->id == id)
+			return client->loadModel(r->path);
+	}
+	return 0;
+}
+
+Bild* KarteDaten::loadBildFromRessource(int id)
+{
+	for (auto r : resources)
+	{
+		if (r->id == id)
+			return client->loadBild(r->path);
+	}
+	return 0;
+}
+
+Model2DData* KarteDaten::loadModelFromPath(const char* path)
+{
+	return client->loadModel(path);
+}
+
+Bild* KarteDaten::loadBildFromPath(const char* path)
+{
+	return client->loadBild(path);
+}
+
+void KarteDaten::loadUnusedResourcePaths(std::function< void(RCArray< Text >*) > callBack)
+{
+	cs.lock();
+	aktionen.add([this, callBack]()
+		{
+			RCArray< Text >* result = new RCArray< Text >();
+			loadSpielResourcePathsFromFolder("data/spiele/Asteroids", result);
+			RCArray< Text >* mapPaths = client->getAllMapResourcePaths();
+			for (auto mp : *mapPaths)
+			{
+				if (!doesResourceExist(mp->getText()))
+					result->add(dynamic_cast<Text*>(mp->getThis()));
+			}
+			mapPaths->release();
+			callBack(result);
+		});
+	cs.unlock();
+}
+
+void KarteDaten::loadSpielResourcePathsFromFolder(const char* folderPath, RCArray< Text >* zPaths)
+{
+	Datei f;
+	f.setDatei(folderPath);
+	if (f.istOrdner())
+	{
+		RCArray< Text >* list = f.getDateiListe();
+		for (auto n : *list)
+		{
+			Text path(folderPath);
+			path += Text("/") + (const char*)n->getText();
+			loadSpielResourcePathsFromFolder(path, zPaths);
+		}
+		list->release();
+	}
+	else
+	{
+		if (f.zPfad()->hat(".ltdb"))
+		{
+			LTDBDatei d;
+			d.setDatei(new Text(folderPath));
+			d.leseDaten(0);
+			int anz = d.getBildAnzahl();
+			for (int i = 0; i < anz; i++)
+			{
+				Text* path = new Text(folderPath);
+				path->ersetzen(0, (int)strlen("data/spiele/Asteroids"), "spiel:");
+				path->append((const char*)(Text("/") + (const char*)d.zBildListe()->z(i)->getText()));
+				if (doesResourceExist(path->getText()))
+					path->release();
+				else
+					zPaths->add(path);
+			}
+		}
+		if (f.zPfad()->hat(".m2"))
+		{
+			M2Datei d;
+			d.setPfad(folderPath);
+			d.leseDaten();
+			int anz = d.getModelAnzahl();
+			for (int i = 0; i < anz; i++)
+			{
+				Text* path = new Text(folderPath);
+				path->ersetzen(0, (int)strlen("data/spiele/Asteroids"), "spiel:");
+				path->append((const char*)(Text("/") + (const char*)d.zModelName(i)->getText()));
+				if (doesResourceExist(path->getText()))
+					path->release();
+				else
+					zPaths->add(path);
+			}
+		}
+		if (f.zPfad()->hat(".gsl"))
+		{
+			HMODULE dll = Framework::getDLLRegister()->ladeDLL("GSL.dll", "data/bin/GSL.dll");
+			GSL::GSLDateiV* d = getGSLDatei();
+			d->setDatei((char*)folderPath);
+			d->leseDaten();
+			int anz = d->getSoundAnzahl();
+			for (int i = 0; i < anz; i++)
+			{
+				Text* path = new Text(folderPath);
+				path->ersetzen(0, (int)strlen("data/spiele/Asteroids"), "spiel:");
+				Text* name = d->getSoundName(i);
+				path->append((const char*)(Text("/") + (const char*)name->getText()));
+				name->release();
+				if (doesResourceExist(path->getText()))
+					path->release();
+				else
+					zPaths->add(path);
+			}
+		}
+	}
 }
 
 // löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
 void KarteDaten::stopWork()
 {
-    if( run )
-    {
-        exit = 1;
-        if( isRunning() )
-            warteAufThread( INT_MAX );
-    }
+	if (run)
+	{
+		exit = 1;
+		if (isRunning())
+			warteAufThread(INT_MAX);
+	}
 }

Asteroids/Editor/Karte/EditorKarte.h

@@ -11,184 +11,184 @@
 
 namespace Editor
 {
-    struct ResourceDaten
-    {
-        int id;
-        Text path;
-    };
-
-    struct SpielerDaten : public Model
-    {
-        int id;
-        Punkt pos;
-        double rot;
-        double beschleunigung;
-        int maxStabilität;
-        int maxEnergie;
-        double reparatur;
-        double akkuLeistung;
-        int laserIntensität;
-        int laserEffizienz;
-        int laserTempo;
-        double wendigkeit;
-        double antriebEffizienz;
-        double energieSchild;
-        double energieSchildEffizienz;
-        int netzwerk;
-        int skillPunkte;
-        int m2d;
-        int bild;
-
-        SpielerDaten();
-        SpielerDaten( const SpielerDaten &daten );
-    };
-
-    struct TeamDaten : public Model
-    {
-        int id;
-        int maxPunkte;
-        double beschleunigung;
-        int maxStabilität;
-        int maxEnergie;
-        double reparatur;
-        double akkuLeistung;
-        int laserIntensität;
-        int laserEffizienz;
-        int laserTempo;
-        double wendigkeit;
-        double antriebEffizienz;
-        double energieSchild;
-        double energieSchildEffizienz;
-        int punkte;
-
-        TeamDaten();
-        TeamDaten( const TeamDaten &daten );
-    };
-
-    struct ObjektDaten : public Model
-    {
-        Punkt pos;
-        float rot;
-        float scale;
-        int id;
-        int m2d;
-        int bild;
-        int style;
-        int maxStabilität;
-        int maxEnergie;
-        int energieRadius;
-        double reparatur;
-        double akkuLeistung;
-        char team;
-
-        ObjektDaten();
-        ObjektDaten( const ObjektDaten &daten );
-    };
-
-    class EditorObject : public Model2DObject
-    {
-    public:
-        enum ObjektTyp
-        {
-            SPIELER,
-            OBJEKT
-        };
-
-    private:
-        ObjektTyp typ;
-        int id;
-
-    public:
-        EditorObject( ObjektTyp typ, int id );
-        virtual ~EditorObject();
-        virtual void update() = 0;
-        bool isObjekt( ObjektTyp typ, int id );
-    };
-
-    class EdSpieler : public EditorObject
-    {
-    private:
-        SpielerDaten *mdl;
-
-    public:
-        EdSpieler( SpielerDaten *model );
-        ~EdSpieler();
-        void update();
-    };
-
-    class EdObjekt : public EditorObject
-    {
-    private:
-        ObjektDaten *mdl;
-
-    public:
-        EdObjekt( ObjektDaten *model );
-        ~EdObjekt();
-        void update();
-    };
-
-    class UpdateObserver : public View
-    {
-    private:
-        std::function< void() > f;
-
-    public:
-        UpdateObserver( std::function< void() > f );
-        void update( Model *m ) override;
-    };
-
-    typedef GSL::GSLDateiV *( *GetGSLDatei )( );
-
-    class KarteDaten : public Thread
-    {
-    private:
-        EditorKlient *client;
-        SpielerTeamStruktur *sts;
-        Array< SpielerDaten * > spieler;
-        Array< TeamDaten * > teams;
-        Array< ObjektDaten * > objekte;
-        Array< ResourceDaten * > resources;
-        Text error;
-        Array< std::function< void() > > aktionen;
-        Critical cs;
-        Welt2D *welt;
-        Punkt size;
-        GetGSLDatei getGSLDatei;
-        bool exit;
-
-        void loadSpielResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths );
-
-    public:
-        KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts );
-        ~KarteDaten();
-        void addObjekt( ObjektDaten &daten, std::function< void( int ) > callBack );
-        void removeObjekt( int index );
-        void thread() override;
-        ResourceDaten *getResource( int index );
-        ObjektDaten *getObjekt( int index );
-        SpielerDaten *getSpieler( int index );
-        TeamDaten *getTeam( int index );
-        const char *getTeamName( int index );
-        int getSpielerIndexById( int id );
-        int getSpielerAnzahl() const;
-        int getTeamIndexById( int id );
-        int getTeamAnzahl() const;
-        int getObjektIndexById( int id );
-        int getObjektAnzahl() const;
-        int getResourceIndexById( int id );
-        int getResourceAnzahl();
-        bool hasError() const;
-        char *getError() const;
-        bool hasAktions() const;
-        Welt2D *getWelt() const;
-        Welt2D *zWelt() const;
-        void getResourceIdFromPath( const char *path, std::function< void( int ) > callBack );
-        bool doesResourceExist( const char *path );
-        Model2DData *loadModelFromRessource( int id );
-        Bild *loadBildFromRessource( int id );
-        Model2DData *loadModelFromPath( const char *path );
-        Bild *loadBildFromPath( const char *path );
-        void loadUnusedResourcePaths( std::function< void( RCArray< Text > * ) > callBack );
-        void stopWork();
-    };
+	struct ResourceDaten
+	{
+		int id;
+		Text path;
+	};
+
+	struct SpielerDaten : public Model
+	{
+		int id;
+		Punkt pos;
+		double rot;
+		double beschleunigung;
+		int maxStabilität;
+		int maxEnergie;
+		double reparatur;
+		double akkuLeistung;
+		int laserIntensität;
+		int laserEffizienz;
+		int laserTempo;
+		double wendigkeit;
+		double antriebEffizienz;
+		double energieSchild;
+		double energieSchildEffizienz;
+		int netzwerk;
+		int skillPunkte;
+		int m2d;
+		int bild;
+
+		SpielerDaten();
+		SpielerDaten(const SpielerDaten& daten);
+	};
+
+	struct TeamDaten : public Model
+	{
+		int id;
+		int maxPunkte;
+		double beschleunigung;
+		int maxStabilität;
+		int maxEnergie;
+		double reparatur;
+		double akkuLeistung;
+		int laserIntensität;
+		int laserEffizienz;
+		int laserTempo;
+		double wendigkeit;
+		double antriebEffizienz;
+		double energieSchild;
+		double energieSchildEffizienz;
+		int punkte;
+
+		TeamDaten();
+		TeamDaten(const TeamDaten& daten);
+	};
+
+	struct ObjektDaten : public Model
+	{
+		Punkt pos;
+		float rot;
+		float scale;
+		int id;
+		int m2d;
+		int bild;
+		int style;
+		int maxStabilität;
+		int maxEnergie;
+		int energieRadius;
+		double reparatur;
+		double akkuLeistung;
+		char team;
+
+		ObjektDaten();
+		ObjektDaten(const ObjektDaten& daten);
+	};
+
+	class EditorObject : public Model2DObject
+	{
+	public:
+		enum ObjektTyp
+		{
+			SPIELER,
+			OBJEKT
+		};
+
+	private:
+		ObjektTyp typ;
+		int id;
+
+	public:
+		EditorObject(ObjektTyp typ, int id);
+		virtual ~EditorObject();
+		virtual void update() = 0;
+		bool isObjekt(ObjektTyp typ, int id);
+	};
+
+	class EdSpieler : public EditorObject
+	{
+	private:
+		SpielerDaten* mdl;
+
+	public:
+		EdSpieler(SpielerDaten* model);
+		~EdSpieler();
+		void update();
+	};
+
+	class EdObjekt : public EditorObject
+	{
+	private:
+		ObjektDaten* mdl;
+
+	public:
+		EdObjekt(ObjektDaten* model);
+		~EdObjekt();
+		void update();
+	};
+
+	class UpdateObserver : public View
+	{
+	private:
+		std::function< void() > f;
+
+	public:
+		UpdateObserver(std::function< void() > f);
+		void update(Model* m) override;
+	};
+
+	typedef GSL::GSLDateiV* (*GetGSLDatei)();
+
+	class KarteDaten : public Thread
+	{
+	private:
+		EditorKlient* client;
+		SpielerTeamStruktur* sts;
+		Array< SpielerDaten* > spieler;
+		Array< TeamDaten* > teams;
+		Array< ObjektDaten* > objekte;
+		Array< ResourceDaten* > resources;
+		Text error;
+		Array< std::function< void() > > aktionen;
+		Critical cs;
+		Welt2D* welt;
+		Punkt size;
+		GetGSLDatei getGSLDatei;
+		bool exit;
+
+		void loadSpielResourcePathsFromFolder(const char* folderPath, RCArray< Text >* zPaths);
+
+	public:
+		KarteDaten(EditorKlient* client, SpielerTeamStruktur* sts);
+		~KarteDaten();
+		void addObjekt(ObjektDaten& daten, std::function< void(int) > callBack);
+		void removeObjekt(int index);
+		void thread() override;
+		ResourceDaten* getResource(int index);
+		ObjektDaten* getObjekt(int index);
+		SpielerDaten* getSpieler(int index);
+		TeamDaten* getTeam(int index);
+		const char* getTeamName(int index);
+		int getSpielerIndexById(int id);
+		int getSpielerAnzahl() const;
+		int getTeamIndexById(int id);
+		int getTeamAnzahl() const;
+		int getObjektIndexById(int id);
+		int getObjektAnzahl() const;
+		int getResourceIndexById(int id);
+		int getResourceAnzahl();
+		bool hasError() const;
+		const char* getError() const;
+		bool hasAktions() const;
+		Welt2D* getWelt() const;
+		Welt2D* zWelt() const;
+		void getResourceIdFromPath(const char* path, std::function< void(int) > callBack);
+		bool doesResourceExist(const char* path);
+		Model2DData* loadModelFromRessource(int id);
+		Bild* loadBildFromRessource(int id);
+		Model2DData* loadModelFromPath(const char* path);
+		Bild* loadBildFromPath(const char* path);
+		void loadUnusedResourcePaths(std::function< void(RCArray< Text >*) > callBack);
+		void stopWork();
+	};
 }

Asteroids/Editor/Netzwerk/EditorKlient.cpp

@@ -9,51 +9,51 @@ using namespace Editor;
 
 SpielerTeamStruktur::SpielerTeamStruktur()
 {
-    spielerAnzahl = 0;
-    teamAnzahl = 0;
-    spielerFarbe = new Array< int >();
-    teamFarbe = new Array< int >();
-    teamName = new RCArray< Text >();
-    teamSize = new Array< int >();
-    ref = 1;
+	spielerAnzahl = 0;
+	teamAnzahl = 0;
+	spielerFarbe = new Array< int >();
+	teamFarbe = new Array< int >();
+	teamName = new RCArray< Text >();
+	teamSize = new Array< int >();
+	ref = 1;
 }
 
 SpielerTeamStruktur::~SpielerTeamStruktur()
 {
-    spielerFarbe->release();
-    teamFarbe->release();
-    teamName->release();
-    teamSize->release();
+	spielerFarbe->release();
+	teamFarbe->release();
+	teamName->release();
+	teamSize->release();
 }
 
 SpielerTeamStrukturV* SpielerTeamStruktur::getThis()
 {
-    ref++;
-    return this;
+	ref++;
+	return this;
 }
 
 SpielerTeamStrukturV* SpielerTeamStruktur::release()
 {
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
+	ref--;
+	if (!ref)
+		delete this;
+	return 0;
 }
 
 
 // Inhalt der EditorKlient Klasse aus EditorKlient.h
 // Konstruktor
 //  k: Der zu verwendende Klient
-EditorKlient::EditorKlient( KSGClient::EditorServerClient* k )
-    : ReferenceCounter()
+EditorKlient::EditorKlient(KSGClient::EditorServerClient* k)
+	: ReferenceCounter()
 {
-    klient = k;
+	klient = k;
 }
 
 // Destruktor
 EditorKlient::~EditorKlient()
 {
-    klient->release();
+	klient->release();
 }
 
 // Initialisiert den Server
@@ -62,698 +62,698 @@ EditorKlient::~EditorKlient()
 //          0, sonnst
 int EditorKlient::init()
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    k->sendeEncrypted( "\x0", 1 );
-    char ret;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-        k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	k->sendeEncrypted("\x0", 1);
+	char ret;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+		k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret;
 }
 
 // Verwirft die vorhandene Sitzung und erstellt eine neue
 bool EditorKlient::sitzungVerwerfen()
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x1", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x1", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
 // Speichert Sitzung und beendet Editor
 bool EditorKlient::sitzungBeenden()
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x2", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x2", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::saveTeam( const TeamDaten* team )
+bool EditorKlient::saveTeam(const TeamDaten* team)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x7", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char*)&team->id, 4 );
-        k->sendeEncrypted( (char*)&team->maxPunkte, 4 );
-        k->sendeEncrypted( (char*)&team->beschleunigung, 8 );
-        k->sendeEncrypted( (char*)&team->maxStabilität, 4 );
-        k->sendeEncrypted( (char*)&team->maxEnergie, 4 );
-        k->sendeEncrypted( (char*)&team->reparatur, 8 );
-        k->sendeEncrypted( (char*)&team->akkuLeistung, 8 );
-        k->sendeEncrypted( (char*)&team->laserIntensität, 4 );
-        k->sendeEncrypted( (char*)&team->laserEffizienz, 4 );
-        k->sendeEncrypted( (char*)&team->laserTempo, 4 );
-        k->sendeEncrypted( (char*)&team->wendigkeit, 8 );
-        k->sendeEncrypted( (char*)&team->antriebEffizienz, 8 );
-        k->sendeEncrypted( (char*)&team->energieSchild, 8 );
-        k->sendeEncrypted( (char*)&team->energieSchildEffizienz, 8 );
-        k->sendeEncrypted( (char*)&team->punkte, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x7", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&team->id, 4);
+		k->sendeEncrypted((char*)&team->maxPunkte, 4);
+		k->sendeEncrypted((char*)&team->beschleunigung, 8);
+		k->sendeEncrypted((char*)&team->maxStabilität, 4);
+		k->sendeEncrypted((char*)&team->maxEnergie, 4);
+		k->sendeEncrypted((char*)&team->reparatur, 8);
+		k->sendeEncrypted((char*)&team->akkuLeistung, 8);
+		k->sendeEncrypted((char*)&team->laserIntensität, 4);
+		k->sendeEncrypted((char*)&team->laserEffizienz, 4);
+		k->sendeEncrypted((char*)&team->laserTempo, 4);
+		k->sendeEncrypted((char*)&team->wendigkeit, 8);
+		k->sendeEncrypted((char*)&team->antriebEffizienz, 8);
+		k->sendeEncrypted((char*)&team->energieSchild, 8);
+		k->sendeEncrypted((char*)&team->energieSchildEffizienz, 8);
+		k->sendeEncrypted((char*)&team->punkte, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::saveSpieler( const SpielerDaten* spieler )
+bool EditorKlient::saveSpieler(const SpielerDaten* spieler)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x6", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char*)&spieler->id, 4 );
-        k->sendeEncrypted( (char*)&spieler->pos.x, 4 );
-        k->sendeEncrypted( (char*)&spieler->pos.y, 4 );
-        k->sendeEncrypted( (char*)&spieler->rot, 8 );
-        k->sendeEncrypted( (char*)&spieler->beschleunigung, 8 );
-        k->sendeEncrypted( (char*)&spieler->maxStabilität, 4 );
-        k->sendeEncrypted( (char*)&spieler->maxEnergie, 4 );
-        k->sendeEncrypted( (char*)&spieler->reparatur, 8 );
-        k->sendeEncrypted( (char*)&spieler->akkuLeistung, 8 );
-        k->sendeEncrypted( (char*)&spieler->laserIntensität, 4 );
-        k->sendeEncrypted( (char*)&spieler->laserEffizienz, 4 );
-        k->sendeEncrypted( (char*)&spieler->laserTempo, 4 );
-        k->sendeEncrypted( (char*)&spieler->wendigkeit, 8 );
-        k->sendeEncrypted( (char*)&spieler->antriebEffizienz, 8 );
-        k->sendeEncrypted( (char*)&spieler->energieSchild, 8 );
-        k->sendeEncrypted( (char*)&spieler->energieSchildEffizienz, 8 );
-        k->sendeEncrypted( (char*)&spieler->netzwerk, 4 );
-        k->sendeEncrypted( (char*)&spieler->skillPunkte, 4 );
-        k->sendeEncrypted( (char*)&spieler->m2d, 4 );
-        k->sendeEncrypted( (char*)&spieler->bild, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x6", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&spieler->id, 4);
+		k->sendeEncrypted((char*)&spieler->pos.x, 4);
+		k->sendeEncrypted((char*)&spieler->pos.y, 4);
+		k->sendeEncrypted((char*)&spieler->rot, 8);
+		k->sendeEncrypted((char*)&spieler->beschleunigung, 8);
+		k->sendeEncrypted((char*)&spieler->maxStabilität, 4);
+		k->sendeEncrypted((char*)&spieler->maxEnergie, 4);
+		k->sendeEncrypted((char*)&spieler->reparatur, 8);
+		k->sendeEncrypted((char*)&spieler->akkuLeistung, 8);
+		k->sendeEncrypted((char*)&spieler->laserIntensität, 4);
+		k->sendeEncrypted((char*)&spieler->laserEffizienz, 4);
+		k->sendeEncrypted((char*)&spieler->laserTempo, 4);
+		k->sendeEncrypted((char*)&spieler->wendigkeit, 8);
+		k->sendeEncrypted((char*)&spieler->antriebEffizienz, 8);
+		k->sendeEncrypted((char*)&spieler->energieSchild, 8);
+		k->sendeEncrypted((char*)&spieler->energieSchildEffizienz, 8);
+		k->sendeEncrypted((char*)&spieler->netzwerk, 4);
+		k->sendeEncrypted((char*)&spieler->skillPunkte, 4);
+		k->sendeEncrypted((char*)&spieler->m2d, 4);
+		k->sendeEncrypted((char*)&spieler->bild, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::saveObjekt( const ObjektDaten* objekt )
+bool EditorKlient::saveObjekt(const ObjektDaten* objekt)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x8", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char*)&objekt->pos.x, 4 );
-        k->sendeEncrypted( (char*)&objekt->pos.y, 4 );
-        k->sendeEncrypted( (char*)&objekt->rot, 4 );
-        k->sendeEncrypted( (char*)&objekt->scale, 4 );
-        k->sendeEncrypted( (char*)&objekt->id, 4 );
-        k->sendeEncrypted( (char*)&objekt->m2d, 4 );
-        k->sendeEncrypted( (char*)&objekt->bild, 4 );
-        k->sendeEncrypted( (char*)&objekt->style, 4 );
-        k->sendeEncrypted( (char*)&objekt->maxStabilität, 4 );
-        k->sendeEncrypted( (char*)&objekt->maxEnergie, 4 );
-        k->sendeEncrypted( (char*)&objekt->energieRadius, 4 );
-        k->sendeEncrypted( (char*)&objekt->reparatur, 8 );
-        k->sendeEncrypted( (char*)&objekt->akkuLeistung, 8 );
-        k->sendeEncrypted( (char*)&objekt->team, 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x8", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&objekt->pos.x, 4);
+		k->sendeEncrypted((char*)&objekt->pos.y, 4);
+		k->sendeEncrypted((char*)&objekt->rot, 4);
+		k->sendeEncrypted((char*)&objekt->scale, 4);
+		k->sendeEncrypted((char*)&objekt->id, 4);
+		k->sendeEncrypted((char*)&objekt->m2d, 4);
+		k->sendeEncrypted((char*)&objekt->bild, 4);
+		k->sendeEncrypted((char*)&objekt->style, 4);
+		k->sendeEncrypted((char*)&objekt->maxStabilität, 4);
+		k->sendeEncrypted((char*)&objekt->maxEnergie, 4);
+		k->sendeEncrypted((char*)&objekt->energieRadius, 4);
+		k->sendeEncrypted((char*)&objekt->reparatur, 8);
+		k->sendeEncrypted((char*)&objekt->akkuLeistung, 8);
+		k->sendeEncrypted((char*)&objekt->team, 1);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::deleteObjekt( int id )
+bool EditorKlient::deleteObjekt(int id)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x9", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char*)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x9", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::loadResources( Array< ResourceDaten* >& resources )
+bool EditorKlient::loadResources(Array< ResourceDaten* >& resources)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\xA", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        int anz = 0;
-        k->getNachrichtEncrypted( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            ResourceDaten* resource = new ResourceDaten();
-            k->getNachrichtEncrypted( (char*)&resource->id, 4 );
-            char len = 0;
-            k->getNachrichtEncrypted( (char*)&len, 1 );
-            char* path = new char[ len + 1 ];
-            path[ len ] = 0;
-            k->getNachrichtEncrypted( path, len );
-            resource->path = path;
-            delete[] path;
-            resources.add( resource );
-        }
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\xA", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			ResourceDaten* resource = new ResourceDaten();
+			k->getNachrichtEncrypted((char*)&resource->id, 4);
+			char len = 0;
+			k->getNachrichtEncrypted((char*)&len, 1);
+			char* path = new char[len + 1];
+			path[len] = 0;
+			k->getNachrichtEncrypted(path, len);
+			resource->path = path;
+			delete[] path;
+			resources.add(resource);
+		}
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-int EditorKlient::addResource( const char* path )
+int EditorKlient::addResource(const char* path)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\xC", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        unsigned char len = (unsigned char)strlen( path );
-        k->sendeEncrypted( (char*)&len, 1 );
-        k->sendeEncrypted( path, len );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int id = 0;
-            k->getNachrichtEncrypted( (char*)&id, 4 );
-            klient->endEditorMessage();
-            return id;
-        }
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return 0;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\xC", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		unsigned char len = (unsigned char)strlen(path);
+		k->sendeEncrypted((char*)&len, 1);
+		k->sendeEncrypted(path, len);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int id = 0;
+			k->getNachrichtEncrypted((char*)&id, 4);
+			klient->endEditorMessage();
+			return id;
+		}
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return 0;
 }
 
-bool EditorKlient::loadSpieler( Array< SpielerDaten* >& spieler )
+bool EditorKlient::loadSpieler(Array< SpielerDaten* >& spieler)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x3", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        int anz = 0;
-        k->getNachrichtEncrypted( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            SpielerDaten* player = new SpielerDaten();
-            k->getNachrichtEncrypted( (char*)&player->id, 4 );
-            k->getNachrichtEncrypted( (char*)&player->pos.x, 4 );
-            k->getNachrichtEncrypted( (char*)&player->pos.y, 4 );
-            k->getNachrichtEncrypted( (char*)&player->rot, 8 );
-            k->getNachrichtEncrypted( (char*)&player->beschleunigung, 8 );
-            k->getNachrichtEncrypted( (char*)&player->maxStabilität, 4 );
-            k->getNachrichtEncrypted( (char*)&player->maxEnergie, 4 );
-            k->getNachrichtEncrypted( (char*)&player->reparatur, 8 );
-            k->getNachrichtEncrypted( (char*)&player->akkuLeistung, 8 );
-            k->getNachrichtEncrypted( (char*)&player->laserIntensität, 4 );
-            k->getNachrichtEncrypted( (char*)&player->laserEffizienz, 4 );
-            k->getNachrichtEncrypted( (char*)&player->laserTempo, 4 );
-            k->getNachrichtEncrypted( (char*)&player->wendigkeit, 8 );
-            k->getNachrichtEncrypted( (char*)&player->antriebEffizienz, 8 );
-            k->getNachrichtEncrypted( (char*)&player->energieSchild, 8 );
-            k->getNachrichtEncrypted( (char*)&player->energieSchildEffizienz, 8 );
-            k->getNachrichtEncrypted( (char*)&player->netzwerk, 4 );
-            k->getNachrichtEncrypted( (char*)&player->skillPunkte, 4 );
-            k->getNachrichtEncrypted( (char*)&player->m2d, 4 );
-            k->getNachrichtEncrypted( (char*)&player->bild, 4 );
-            spieler.add( player );
-        }
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x3", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			SpielerDaten* player = new SpielerDaten();
+			k->getNachrichtEncrypted((char*)&player->id, 4);
+			k->getNachrichtEncrypted((char*)&player->pos.x, 4);
+			k->getNachrichtEncrypted((char*)&player->pos.y, 4);
+			k->getNachrichtEncrypted((char*)&player->rot, 8);
+			k->getNachrichtEncrypted((char*)&player->beschleunigung, 8);
+			k->getNachrichtEncrypted((char*)&player->maxStabilität, 4);
+			k->getNachrichtEncrypted((char*)&player->maxEnergie, 4);
+			k->getNachrichtEncrypted((char*)&player->reparatur, 8);
+			k->getNachrichtEncrypted((char*)&player->akkuLeistung, 8);
+			k->getNachrichtEncrypted((char*)&player->laserIntensität, 4);
+			k->getNachrichtEncrypted((char*)&player->laserEffizienz, 4);
+			k->getNachrichtEncrypted((char*)&player->laserTempo, 4);
+			k->getNachrichtEncrypted((char*)&player->wendigkeit, 8);
+			k->getNachrichtEncrypted((char*)&player->antriebEffizienz, 8);
+			k->getNachrichtEncrypted((char*)&player->energieSchild, 8);
+			k->getNachrichtEncrypted((char*)&player->energieSchildEffizienz, 8);
+			k->getNachrichtEncrypted((char*)&player->netzwerk, 4);
+			k->getNachrichtEncrypted((char*)&player->skillPunkte, 4);
+			k->getNachrichtEncrypted((char*)&player->m2d, 4);
+			k->getNachrichtEncrypted((char*)&player->bild, 4);
+			spieler.add(player);
+		}
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::loadTeams( Array< TeamDaten* >& teams )
+bool EditorKlient::loadTeams(Array< TeamDaten* >& teams)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x4", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        int anz = 0;
-        k->getNachrichtEncrypted( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            TeamDaten* team = new TeamDaten();
-            k->getNachrichtEncrypted( (char*)&team->id, 4 );
-            k->getNachrichtEncrypted( (char*)&team->maxPunkte, 4 );
-            k->getNachrichtEncrypted( (char*)&team->beschleunigung, 8 );
-            k->getNachrichtEncrypted( (char*)&team->maxStabilität, 4 );
-            k->getNachrichtEncrypted( (char*)&team->maxEnergie, 4 );
-            k->getNachrichtEncrypted( (char*)&team->reparatur, 8 );
-            k->getNachrichtEncrypted( (char*)&team->akkuLeistung, 8 );
-            k->getNachrichtEncrypted( (char*)&team->laserIntensität, 4 );
-            k->getNachrichtEncrypted( (char*)&team->laserEffizienz, 4 );
-            k->getNachrichtEncrypted( (char*)&team->laserTempo, 4 );
-            k->getNachrichtEncrypted( (char*)&team->wendigkeit, 8 );
-            k->getNachrichtEncrypted( (char*)&team->antriebEffizienz, 8 );
-            k->getNachrichtEncrypted( (char*)&team->energieSchild, 8 );
-            k->getNachrichtEncrypted( (char*)&team->energieSchildEffizienz, 8 );
-            k->getNachrichtEncrypted( (char*)&team->punkte, 4 );
-            teams.add( team );
-        }
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x4", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			TeamDaten* team = new TeamDaten();
+			k->getNachrichtEncrypted((char*)&team->id, 4);
+			k->getNachrichtEncrypted((char*)&team->maxPunkte, 4);
+			k->getNachrichtEncrypted((char*)&team->beschleunigung, 8);
+			k->getNachrichtEncrypted((char*)&team->maxStabilität, 4);
+			k->getNachrichtEncrypted((char*)&team->maxEnergie, 4);
+			k->getNachrichtEncrypted((char*)&team->reparatur, 8);
+			k->getNachrichtEncrypted((char*)&team->akkuLeistung, 8);
+			k->getNachrichtEncrypted((char*)&team->laserIntensität, 4);
+			k->getNachrichtEncrypted((char*)&team->laserEffizienz, 4);
+			k->getNachrichtEncrypted((char*)&team->laserTempo, 4);
+			k->getNachrichtEncrypted((char*)&team->wendigkeit, 8);
+			k->getNachrichtEncrypted((char*)&team->antriebEffizienz, 8);
+			k->getNachrichtEncrypted((char*)&team->energieSchild, 8);
+			k->getNachrichtEncrypted((char*)&team->energieSchildEffizienz, 8);
+			k->getNachrichtEncrypted((char*)&team->punkte, 4);
+			teams.add(team);
+		}
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-bool EditorKlient::loadObjekte( Array< ObjektDaten* >& objekte )
+bool EditorKlient::loadObjekte(Array< ObjektDaten* >& objekte)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\x5", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        int anz = 0;
-        k->getNachrichtEncrypted( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            ObjektDaten* objekt = new ObjektDaten();
-            k->getNachrichtEncrypted( (char*)&objekt->pos.x, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->pos.y, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->rot, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->scale, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->id, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->m2d, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->bild, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->style, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->maxStabilität, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->maxEnergie, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->energieRadius, 4 );
-            k->getNachrichtEncrypted( (char*)&objekt->reparatur, 8 );
-            k->getNachrichtEncrypted( (char*)&objekt->akkuLeistung, 8 );
-            k->getNachrichtEncrypted( (char*)&objekt->team, 1 );
-            objekte.add( objekt );
-        }
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\x5", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			ObjektDaten* objekt = new ObjektDaten();
+			k->getNachrichtEncrypted((char*)&objekt->pos.x, 4);
+			k->getNachrichtEncrypted((char*)&objekt->pos.y, 4);
+			k->getNachrichtEncrypted((char*)&objekt->rot, 4);
+			k->getNachrichtEncrypted((char*)&objekt->scale, 4);
+			k->getNachrichtEncrypted((char*)&objekt->id, 4);
+			k->getNachrichtEncrypted((char*)&objekt->m2d, 4);
+			k->getNachrichtEncrypted((char*)&objekt->bild, 4);
+			k->getNachrichtEncrypted((char*)&objekt->style, 4);
+			k->getNachrichtEncrypted((char*)&objekt->maxStabilität, 4);
+			k->getNachrichtEncrypted((char*)&objekt->maxEnergie, 4);
+			k->getNachrichtEncrypted((char*)&objekt->energieRadius, 4);
+			k->getNachrichtEncrypted((char*)&objekt->reparatur, 8);
+			k->getNachrichtEncrypted((char*)&objekt->akkuLeistung, 8);
+			k->getNachrichtEncrypted((char*)&objekt->team, 1);
+			objekte.add(objekt);
+		}
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
-Bild* EditorKlient::loadBild( const char* templatePath )
+Bild* EditorKlient::loadBild(const char* templatePath)
 {
-    Text txt( templatePath );
-    Text pfad;
-    if( txt.positionVon( "spiel:" ) == 0 )
-    {
-        pfad = "data/spiele/Asteroids";
-        pfad.append( txt.getTeilText( 6 ) );
-        if( pfad.hat( ".ltdb/" ) )
-        {
-            int pos = pfad.positionVon( ".ltdb/", pfad.anzahlVon( ".ltdb/" ) - 1 );
-            LTDBDatei datei;
-            datei.setDatei( pfad.getTeilText( 0, pos + 5 ) );
-            datei.leseDaten( 0 );
-            return datei.laden( 0, pfad.getTeilText( pos + 6 ) );
-        }
-    }
-    if( txt.positionVon( "map:" ) == 0 )
-    {
-        pfad.append( txt.getTeilText( 5 ) );
-        if( pfad.hat( ".ltdb/" ) )
-        {
-            cs.lock();
-            if( klient->deResetPath() )
-            {
-                while( pfad.anzahlVon( "/" ) > 1 )
-                {
-                    Text* name = pfad.getTeilText( 0, pfad.positionVon( "/" ) );
-                    klient->deOrdnerÖffnen( name );
-                    pfad.remove( 0, name->getLength() + 1 );
-                    name->release();
-                }
-                Text* datei = pfad.getTeilText( 0, pfad.positionVon( ".ltdb/" ) + 5 );
-                Text* bild = pfad.getTeilText( pfad.positionVon( ".ltdb/" ) + 6 );
-                Bild* res = klient->deBildLaden( datei, bild, 0 );
-                datei->release();
-                bild->release();
-                cs.unlock();
-                return res;
-            }
-            cs.unlock();
-        }
-    }
-    error = klient->getLetzterFehler();
-    return 0;
+	Text txt(templatePath);
+	Text pfad;
+	if (txt.positionVon("spiel:") == 0)
+	{
+		pfad = "data/spiele/Asteroids";
+		pfad.append(txt.getTeilText(6));
+		if (pfad.hat(".ltdb/"))
+		{
+			int pos = pfad.positionVon(".ltdb/", pfad.anzahlVon(".ltdb/") - 1);
+			LTDBDatei datei;
+			datei.setDatei(pfad.getTeilText(0, pos + 5));
+			datei.leseDaten(0);
+			return datei.laden(0, pfad.getTeilText(pos + 6));
+		}
+	}
+	if (txt.positionVon("map:") == 0)
+	{
+		pfad.append(txt.getTeilText(5));
+		if (pfad.hat(".ltdb/"))
+		{
+			cs.lock();
+			if (klient->deResetPath())
+			{
+				while (pfad.anzahlVon("/") > 1)
+				{
+					Text* name = pfad.getTeilText(0, pfad.positionVon("/"));
+					klient->deOrdnerÖffnen(name);
+					pfad.remove(0, name->getLength() + 1);
+					name->release();
+				}
+				Text* datei = pfad.getTeilText(0, pfad.positionVon(".ltdb/") + 5);
+				Text* bild = pfad.getTeilText(pfad.positionVon(".ltdb/") + 6);
+				Bild* res = klient->deBildLaden(datei, bild, 0);
+				datei->release();
+				bild->release();
+				cs.unlock();
+				return res;
+			}
+			cs.unlock();
+		}
+	}
+	error = klient->getLetzterFehler();
+	return 0;
 }
 
-Model2DData* EditorKlient::loadModel( const char* templatePath )
+Model2DData* EditorKlient::loadModel(const char* templatePath)
 {
-    Text txt( templatePath );
-    Text pfad;
-    if( txt.positionVon( "spiel:" ) == 0 )
-    {
-        pfad = "data/spiele/Asteroids";
-        pfad.append( txt.getTeilText( 6 ) );
-        if( pfad.hat( ".m2/" ) )
-        {
-            int pos = pfad.positionVon( ".m2/", pfad.anzahlVon( ".m2/" ) - 1 );
-            M2Datei datei;
-            Text* file = pfad.getTeilText( 0, pos + 3 );
-            datei.setPfad( file->getText() );
-            file->release();
-            datei.leseDaten();
-            return datei.ladeModel( pfad.getTeilText( pos + 4 ) );
-        }
-    }
-    if( txt.positionVon( "map:" ) == 0 )
-    {
-        pfad.append( txt.getTeilText( 5 ) );
-        if( pfad.hat( ".m2/" ) )
-        {
-            cs.lock();
-            if( klient->deResetPath() )
-            {
-                while( pfad.anzahlVon( "/" ) > 1 )
-                {
-                    Text* name = pfad.getTeilText( 0, pfad.positionVon( "/" ) );
-                    klient->deOrdnerÖffnen( name );
-                    pfad.remove( 0, name->getLength() + 1 );
-                    name->release();
-                }
-                Text* datei = pfad.getTeilText( 0, pfad.positionVon( ".m2/" ) + 3 );
-                Text* model = pfad.getTeilText( pfad.positionVon( ".m2/" ) + 4 );
-                Model2DData* res = klient->deModelLaden( datei, model, 0 );
-                datei->release();
-                model->release();
-                cs.unlock();
-                return res;
-            }
-            cs.unlock();
-        }
-    }
-    error = klient->getLetzterFehler();
-    return 0;
+	Text txt(templatePath);
+	Text pfad;
+	if (txt.positionVon("spiel:") == 0)
+	{
+		pfad = "data/spiele/Asteroids";
+		pfad.append(txt.getTeilText(6));
+		if (pfad.hat(".m2/"))
+		{
+			int pos = pfad.positionVon(".m2/", pfad.anzahlVon(".m2/") - 1);
+			M2Datei datei;
+			Text* file = pfad.getTeilText(0, pos + 3);
+			datei.setPfad(file->getText());
+			file->release();
+			datei.leseDaten();
+			return datei.ladeModel(pfad.getTeilText(pos + 4));
+		}
+	}
+	if (txt.positionVon("map:") == 0)
+	{
+		pfad.append(txt.getTeilText(5));
+		if (pfad.hat(".m2/"))
+		{
+			cs.lock();
+			if (klient->deResetPath())
+			{
+				while (pfad.anzahlVon("/") > 1)
+				{
+					Text* name = pfad.getTeilText(0, pfad.positionVon("/"));
+					klient->deOrdnerÖffnen(name);
+					pfad.remove(0, name->getLength() + 1);
+					name->release();
+				}
+				Text* datei = pfad.getTeilText(0, pfad.positionVon(".m2/") + 3);
+				Text* model = pfad.getTeilText(pfad.positionVon(".m2/") + 4);
+				Model2DData* res = klient->deModelLaden(datei, model, 0);
+				datei->release();
+				model->release();
+				cs.unlock();
+				return res;
+			}
+			cs.unlock();
+		}
+	}
+	error = klient->getLetzterFehler();
+	return 0;
 }
 
 RCArray< Text >* EditorKlient::getAllMapResourcePaths()
 {
-    cs.lock();
-    klient->deResetPath();
-    RCArray< Text >* result = new RCArray< Text >();
-    loadMapResourcePathsFromFolder( "map:", result );
-    cs.unlock();
-    return result;
+	cs.lock();
+	klient->deResetPath();
+	RCArray< Text >* result = new RCArray< Text >();
+	loadMapResourcePathsFromFolder("map:", result);
+	cs.unlock();
+	return result;
 }
 
-void EditorKlient::loadMapResourcePathsFromFolder( const char* folderPath, RCArray< Text >* zPaths )
+void EditorKlient::loadMapResourcePathsFromFolder(const char* folderPath, RCArray< Text >* zPaths)
 {
-    RCArray< Text >* files = new RCArray< Text >();
-    klient->deGetDateiListe( files );
-    for( auto f : *files )
-    {
-        Text path( folderPath );
-        path += Text( "/" ) + *f;
-        if( !f->hat( "." ) )
-        {
-            klient->deOrdnerÖffnen( f );
-            loadMapResourcePathsFromFolder( path, zPaths );
-            Text back = "..";
-            klient->deOrdnerÖffnen( &back );
-        }
-        else if( f->hat( ".ltdb" ) )
-        {
-            RCArray< Text >* bilder = new RCArray< Text >();
-            klient->deGetBildListe( f, bilder );
-            for( auto n : *bilder )
-                zPaths->add( new Text( path + "/" + *n ) );
-            bilder->release();
-        }
-        else if( f->hat( ".m2" ) )
-        {
-            RCArray< Text >* models = new RCArray< Text >();
-            klient->deGetModelListe( f, models );
-            for( auto n : *models )
-                zPaths->add( new Text( path + "/" + *n ) );
-            models->release();
-        }
-        else if( f->hat( ".gsl" ) )
-        {
-            RCArray< Text >* sounds = new RCArray< Text >();
-            klient->deGetSoundListe( f, sounds );
-            for( auto n : *sounds )
-                zPaths->add( new Text( path + "/" + *n ) );
-            sounds->release();
-        }
-    }
-    files->release();
+	RCArray< Text >* files = new RCArray< Text >();
+	klient->deGetDateiListe(files);
+	for (auto f : *files)
+	{
+		Text path(folderPath);
+		path += Text("/") + *f;
+		if (!f->hat("."))
+		{
+			klient->deOrdnerÖffnen(f);
+			loadMapResourcePathsFromFolder(path, zPaths);
+			Text back = "..";
+			klient->deOrdnerÖffnen(&back);
+		}
+		else if (f->hat(".ltdb"))
+		{
+			RCArray< Text >* bilder = new RCArray< Text >();
+			klient->deGetBildListe(f, bilder);
+			for (auto n : *bilder)
+				zPaths->add(new Text(path + "/" + *n));
+			bilder->release();
+		}
+		else if (f->hat(".m2"))
+		{
+			RCArray< Text >* models = new RCArray< Text >();
+			klient->deGetModelListe(f, models);
+			for (auto n : *models)
+				zPaths->add(new Text(path + "/" + *n));
+			models->release();
+		}
+		else if (f->hat(".gsl"))
+		{
+			RCArray< Text >* sounds = new RCArray< Text >();
+			klient->deGetSoundListe(f, sounds);
+			for (auto n : *sounds)
+				zPaths->add(new Text(path + "/" + *n));
+			sounds->release();
+		}
+	}
+	files->release();
 }
 
 // Lädt die Spieler Team Struktur
-bool EditorKlient::getSpielerTeamStruktur( SpielerTeamStrukturV* sts )
+bool EditorKlient::getSpielerTeamStruktur(SpielerTeamStrukturV* sts)
 {
-    return klient->ladeTeamDaten( sts );
+	return klient->ladeTeamDaten(sts);
 }
 
-bool EditorKlient::loadMapSize( Punkt& size )
+bool EditorKlient::loadMapSize(Punkt& size)
 {
-    Network::Klient* k = klient->beginEditorMessage();
-    if( !k )
-    {
-        error = klient->getLetzterFehler();
-        return 0;
-    }
-    error = "";
-    char ret;
-    k->sendeEncrypted( "\xB", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->getNachrichtEncrypted( (char*)&size.x, 4 );
-        k->getNachrichtEncrypted( (char*)&size.y, 4 );
-    }
-    if( ret == 3 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char*)&l, 1 );
-        char* err = new char[ l + 1 ];
-        err[ l ] = 0;
-        k->getNachrichtEncrypted( err, l );
-        error = err;
-        delete[] err;
-        ret = 0;
-    }
-    klient->endEditorMessage();
-    return ret == 1;
+	Network::Klient* k = klient->beginEditorMessage();
+	if (!k)
+	{
+		error = klient->getLetzterFehler();
+		return 0;
+	}
+	error = "";
+	char ret;
+	k->sendeEncrypted("\xB", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->getNachrichtEncrypted((char*)&size.x, 4);
+		k->getNachrichtEncrypted((char*)&size.y, 4);
+	}
+	if (ret == 3)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* err = new char[l + 1];
+		err[l] = 0;
+		k->getNachrichtEncrypted(err, l);
+		error = err;
+		delete[] err;
+		ret = 0;
+	}
+	klient->endEditorMessage();
+	return ret == 1;
 }
 
 // Gibt den Letzten Fehler zurück
-char* EditorKlient::getLastError() const
+const char* EditorKlient::getLastError() const
 {
-    return error;
+	return error;
 }

Asteroids/Editor/Netzwerk/EditorKlient.h

@@ -6,60 +6,60 @@
 
 namespace Editor
 {
-    struct ResourceDaten;
-    struct TeamDaten;
-    struct SpielerDaten;
-    struct ObjektDaten;
+	struct ResourceDaten;
+	struct TeamDaten;
+	struct SpielerDaten;
+	struct ObjektDaten;
 
-    class SpielerTeamStruktur : public SpielerTeamStrukturV
-    {
-    public:
-        SpielerTeamStruktur();
-        ~SpielerTeamStruktur();
-        SpielerTeamStrukturV *getThis() override;
-        SpielerTeamStrukturV *release() override;
-    };
+	class SpielerTeamStruktur : public SpielerTeamStrukturV
+	{
+	public:
+		SpielerTeamStruktur();
+		~SpielerTeamStruktur();
+		SpielerTeamStrukturV* getThis() override;
+		SpielerTeamStrukturV* release() override;
+	};
 
-    class EditorKlient : public virtual ReferenceCounter
-    {
-    private:
-        KSGClient::EditorServerClient *klient;
-        Text error;
-        Critical cs;
+	class EditorKlient : public virtual ReferenceCounter
+	{
+	private:
+		KSGClient::EditorServerClient* klient;
+		Text error;
+		Critical cs;
 
-        void loadMapResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths );
+		void loadMapResourcePathsFromFolder(const char* folderPath, RCArray< Text >* zPaths);
 
-    public:
-        // Konstruktor
-        //  k: Der zu verwendende Klient
-        EditorKlient( KSGClient::EditorServerClient *k );
-        // Destruktor
-        ~EditorKlient();
-        // Initialisiert den Server
-        //  return: 1, falls erfolgreich
-        //          2, falls bereits eine Sitzung existiert
-        //          0, sonnst
-        int init();
-        // Verwirft die vorhandene Sitzung und erstellt eine neue
-        bool sitzungVerwerfen();
-        // Speichert Sitzung und beendet Editor
-        bool sitzungBeenden();
-        // Lädt die Spieler Team Struktur
-        bool getSpielerTeamStruktur( SpielerTeamStrukturV *zSts );
-        bool loadMapSize( Punkt &size );
-        bool saveTeam( const TeamDaten *team );
-        bool saveSpieler( const SpielerDaten *spieler );
-        bool saveObjekt( const ObjektDaten *objekt );
-        bool deleteObjekt( int id );
-        bool loadResources( Array< ResourceDaten * > &resources );
-        int addResource( const char *path );
-        bool loadSpieler( Array< SpielerDaten * > &spieler );
-        bool loadTeams( Array< TeamDaten * > &teams );
-        bool loadObjekte( Array< ObjektDaten * > &Objekte );
-        Bild *loadBild( const char *templatePath );
-        Model2DData *loadModel( const char *templatePath );
-        RCArray< Text > *getAllMapResourcePaths();
-        // Gibt den Letzten Fehler zurück
-        char *getLastError() const;
-    };
+	public:
+		// Konstruktor
+		//  k: Der zu verwendende Klient
+		EditorKlient(KSGClient::EditorServerClient* k);
+		// Destruktor
+		~EditorKlient();
+		// Initialisiert den Server
+		//  return: 1, falls erfolgreich
+		//          2, falls bereits eine Sitzung existiert
+		//          0, sonnst
+		int init();
+		// Verwirft die vorhandene Sitzung und erstellt eine neue
+		bool sitzungVerwerfen();
+		// Speichert Sitzung und beendet Editor
+		bool sitzungBeenden();
+		// Lädt die Spieler Team Struktur
+		bool getSpielerTeamStruktur(SpielerTeamStrukturV* zSts);
+		bool loadMapSize(Punkt& size);
+		bool saveTeam(const TeamDaten* team);
+		bool saveSpieler(const SpielerDaten* spieler);
+		bool saveObjekt(const ObjektDaten* objekt);
+		bool deleteObjekt(int id);
+		bool loadResources(Array< ResourceDaten* >& resources);
+		int addResource(const char* path);
+		bool loadSpieler(Array< SpielerDaten* >& spieler);
+		bool loadTeams(Array< TeamDaten* >& teams);
+		bool loadObjekte(Array< ObjektDaten* >& Objekte);
+		Bild* loadBild(const char* templatePath);
+		Model2DData* loadModel(const char* templatePath);
+		RCArray< Text >* getAllMapResourcePaths();
+		// Gibt den Letzten Fehler zurück
+		const char* getLastError() const;
+	};
 }

Asteroids/Initialisierung/Initialisierung.cpp

@@ -3,103 +3,103 @@
 #include <Bildschirm.h>
 #include <MausEreignis.h>
 
-Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel )
+Knopf* initKnopf(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* titel)
 {
-    Knopf *ret = uiFactory.createKnopf( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    if( titel )
-        ret->setText( titel );
-    return ret;
+	Knopf* ret = uiFactory.createKnopf(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	if (titel)
+		ret->setText(titel);
+	return ret;
 }
 
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt )
+KontrollKnopf* initKontrollKnopf(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* txt)
 {
-    KontrollKnopf *ret = uiFactory.createKontrollKnopf( uiFactory.initParam );
-    ret->addStyle( style );
-    if( txt )
-    {
-        ret->setText( txt );
-        ret->setSText( txt );
-    }
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    return ret;
+	KontrollKnopf* ret = uiFactory.createKontrollKnopf(uiFactory.initParam);
+	ret->addStyle(style);
+	if (txt)
+	{
+		ret->setText(txt);
+		ret->setSText(txt);
+	}
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	return ret;
 }
 
-Fenster *initFenster( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel )
+Fenster* initFenster(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* titel)
 {
-    Fenster *ret = uiFactory.createFenster( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    if( ret->hatStyle( Fenster::Style::Titel ) )
-    {
-        if( titel )
-            ret->setTitel( titel );
-    }
-    return ret;
+	Fenster* ret = uiFactory.createFenster(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	if (ret->hatStyle(Fenster::Style::Titel))
+	{
+		if (titel)
+			ret->setTitel(titel);
+	}
+	return ret;
 }
 
-TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt )
+TextFeld* initTextFeld(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* txt)
 {
-    TextFeld *ret = uiFactory.createTextFeld( uiFactory.initParam );
-    ret->setStyle( style );
-    if( txt )
-        ret->setText( txt );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    return ret;
+	TextFeld* ret = uiFactory.createTextFeld(uiFactory.initParam);
+	ret->setStyle(style);
+	if (txt)
+		ret->setText(txt);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	return ret;
 }
 
-BildZ *initBildZ( int x, int y, int br, int hö, UIInit &uiFactory, int style, Bild *b )
+BildZ* initBildZ(int x, int y, int br, int hö, UIInit& uiFactory, int style, Bild* b)
 {
-    BildZ *ret = uiFactory.createBildZ( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    if( b )
-        ret->setBildZ( b );
-    return ret;
+	BildZ* ret = uiFactory.createBildZ(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	if (b)
+		ret->setBildZ(b);
+	return ret;
 }
 
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values )
+AuswahlBox* initAuswahlBox(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, std::initializer_list< const char* > values)
 {
-    AuswahlBox *ret = uiFactory.createAuswahlBox( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    for( auto i = values.begin(); i != values.end(); i++ )
-    {
-        ret->addEintrag( *i );
-    }
-    return ret;
+	AuswahlBox* ret = uiFactory.createAuswahlBox(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	for (auto i = values.begin(); i != values.end(); i++)
+	{
+		ret->addEintrag(*i);
+	}
+	return ret;
 }
 
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
+ObjTabelle* initObjTabelle(int x, int y, int br, int hö, UIInit& uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe)
 {
-    ObjTabelle *ret = uiFactory.createObjTabelle( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    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, uiFactory, TextFeld::Style::Text, i->name ) );
-        }
-    }
-    return ret;
+	ObjTabelle* ret = uiFactory.createObjTabelle(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	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, uiFactory, TextFeld::Style::Text, i->name));
+		}
+	}
+	return ret;
 }

Asteroids/Initialisierung/Initialisierung.h

@@ -15,18 +15,18 @@ using namespace Framework;
 
 struct OBJTabelleSpalteIni
 {
-    char *name;
-    int breite;
-    int minBreite;
-    int maxBreite;
+	char* name;
+	int breite;
+	int minBreite;
+	int maxBreite;
 };
 
-Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel );
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt );
-Fenster *initFenster( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel );
-TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt );
-BildZ *initBildZ( int x, int y, int br, int hö, UIInit &uiFactory, int style, Bild *b );
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values );
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
+Knopf* initKnopf(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* titel);
+KontrollKnopf* initKontrollKnopf(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* txt);
+Fenster* initFenster(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* titel);
+TextFeld* initTextFeld(int x, int y, int br, int hö, UIInit& uiFactory, int style, const char* txt);
+BildZ* initBildZ(int x, int y, int br, int hö, UIInit& uiFactory, int style, Bild* b);
+AuswahlBox* initAuswahlBox(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, std::initializer_list< const char* > values);
+ObjTabelle* initObjTabelle(int x, int y, int br, int hö, UIInit& uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe);
 
 #endif

Asteroids/Spiel/Bestenliste/Bestenliste.cpp

@@ -7,413 +7,413 @@
 #include "../../Initialisierung/Initialisierung.h"
 #include "..\Spieler\Spieler.h"
 
-int getStellen( double d );
+int getStellen(double d);
 
 // Inhalt der BLSpieler Klasse aus Bestenliste.h
 // Konstruktor
-BLSpieler::BLSpieler( int sNum, UIInit &uiFactory )
-    : ReferenceCounter()
+BLSpieler::BLSpieler(int sNum, UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    this->sNum = sNum;
-
-    rahmen = new LRahmen();
-    rahmen->setRamenBreite( 1 );
-    rahmen->setSize( 420, 20 );
-    name = initTextFeld( 0, 0, 100, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    punkte = initTextFeld( 100, 0, 50, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    kills = initTextFeld( 150, 0, 40, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    tode = initTextFeld( 190, 0, 40, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    schadenGemacht = initTextFeld( 230, 0, 60, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    schadenGenommen = initTextFeld( 290, 0, 60, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    präzision = initTextFeld( 350, 0, 70, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	this->sNum = sNum;
+
+	rahmen = new LRahmen();
+	rahmen->setRamenBreite(1);
+	rahmen->setSize(420, 20);
+	name = initTextFeld(0, 0, 100, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	punkte = initTextFeld(100, 0, 50, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	kills = initTextFeld(150, 0, 40, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	tode = initTextFeld(190, 0, 40, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	schadenGemacht = initTextFeld(230, 0, 60, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	schadenGenommen = initTextFeld(290, 0, 60, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	präzision = initTextFeld(350, 0, 70, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
 }
 
 // Destruktor
 BLSpieler::~BLSpieler()
 {
-    rahmen->release();
-    name->release();
-    punkte->release();
-    kills->release();
-    tode->release();
-    schadenGemacht->release();
-    schadenGenommen->release();
-    präzision->release();
+	rahmen->release();
+	name->release();
+	punkte->release();
+	kills->release();
+	tode->release();
+	schadenGemacht->release();
+	schadenGenommen->release();
+	präzision->release();
 }
 
 // nicht constant
-bool BLSpieler::update( Spieler *zSpieler )
+bool BLSpieler::update(Spieler* zSpieler)
 {
-    if( sNum != zSpieler->getSpielerNummer() )
-        return 0;
-    rahmen->setFarbe( zSpieler->getSpielerFarbe() );
-    name->setText( zSpieler->zName()->getText() );
-    name->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    punkte->setText( Text() += zSpieler->getPunkte() );
-    punkte->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    kills->setText( Text() += zSpieler->getKills() );
-    kills->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    tode->setText( Text() += zSpieler->getTode() );
-    tode->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    schadenGemacht->setText( Text() += zSpieler->getSchadenGemacht() );
-    schadenGemacht->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    schadenGenommen->setText( Text() += zSpieler->getSchadenBekommen() );
-    schadenGenommen->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    Text txt;
-    double d = 100 * ( (double)zSpieler->getTreffer() / zSpieler->getSchüsse() );
-    if( !zSpieler->getSchüsse() )
-        d = 0;
-    txt.setPrecision( getStellen( d ) + 2 );
-    txt += d;
-    präzision->setText( txt );
-    präzision->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-    return 1;
+	if (sNum != zSpieler->getSpielerNummer())
+		return 0;
+	rahmen->setFarbe(zSpieler->getSpielerFarbe());
+	name->setText(zSpieler->zName()->getText());
+	name->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	punkte->setText(Text() += zSpieler->getPunkte());
+	punkte->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	kills->setText(Text() += zSpieler->getKills());
+	kills->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	tode->setText(Text() += zSpieler->getTode());
+	tode->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	schadenGemacht->setText(Text() += zSpieler->getSchadenGemacht());
+	schadenGemacht->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	schadenGenommen->setText(Text() += zSpieler->getSchadenBekommen());
+	schadenGenommen->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	Text txt;
+	double d = 100 * ((double)zSpieler->getTreffer() / zSpieler->getSchüsse());
+	if (!zSpieler->getSchüsse())
+		d = 0;
+	txt.setPrecision(getStellen(d) + 2);
+	txt += d;
+	präzision->setText(txt);
+	präzision->setSchriftFarbe(zSpieler->getSpielerFarbe());
+	return 1;
 }
 
-void BLSpieler::render( int y, Bild &zRObj )
+void BLSpieler::render(int y, Bild& zRObj)
 {
-    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-        return;
-    rahmen->render( zRObj );
-    name->render( zRObj );
-    punkte->render( zRObj );
-    kills->render( zRObj );
-    tode->render( zRObj );
-    schadenGemacht->render( zRObj );
-    schadenGenommen->render( zRObj );
-    präzision->render( zRObj );
-    zRObj.releaseDrawOptions();
+	if (!zRObj.setDrawOptions(1, y, rahmen->getBreite(), rahmen->getHeight()))
+		return;
+	rahmen->render(zRObj);
+	name->render(zRObj);
+	punkte->render(zRObj);
+	kills->render(zRObj);
+	tode->render(zRObj);
+	schadenGemacht->render(zRObj);
+	schadenGenommen->render(zRObj);
+	präzision->render(zRObj);
+	zRObj.releaseDrawOptions();
 }
 
 // constant
 int BLSpieler::getSpielerNummer() const
 {
-    return sNum;
+	return sNum;
 }
 
 int BLSpieler::getPunkte() const
 {
-    return *punkte->zText();
+	return (int)*punkte->zText();
 }
 
 // Inhalt der BLTeam Klasse aus Bestenliste.h
 // Konstruktor
-BLTeam::BLTeam( int id, UIInit &uiFactory )
-    : ReferenceCounter()
+BLTeam::BLTeam(int id, UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    teamId = id;
-    spielerAnzahl = 0;
-    this->uiFactory = uiFactory;
-    spieler = new RCArray< BLSpieler >();
-
-    rahmen = new LRahmen();
-    rahmen->setRamenBreite( 1 );
-    name = initTextFeld( 0, 0, 100, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-    punkte = initTextFeld( 100, 0, 50, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	teamId = id;
+	spielerAnzahl = 0;
+	this->uiFactory = uiFactory;
+	spieler = new RCArray< BLSpieler >();
+
+	rahmen = new LRahmen();
+	rahmen->setRamenBreite(1);
+	name = initTextFeld(0, 0, 100, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
+	punkte = initTextFeld(100, 0, 50, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "");
 }
 
 // Destruktor
 BLTeam::~BLTeam()
 {
-    rahmen->release();
-    spieler->release();
-    name->release();
-    punkte->release();
+	rahmen->release();
+	spieler->release();
+	name->release();
+	punkte->release();
 }
 
 // nicht constant
-bool BLTeam::addSpieler( Spieler *zSpieler )
+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(), uiFactory );
-    tmp->update( zSpieler );
-    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(), uiFactory);
+	tmp->update(zSpieler);
+	spieler->set(tmp, spielerAnzahl);
+	spielerAnzahl++;
+	return 1;
 }
 
-bool BLTeam::updateSpieler( Spieler *zSpieler )
+bool BLTeam::updateSpieler(Spieler* zSpieler)
 {
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-        {
-            spieler->z( i )->update( zSpieler );
-            return 1;
-        }
-    }
-    return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (spieler->z(i)->getSpielerNummer() == zSpieler->getSpielerNummer())
+		{
+			spieler->z(i)->update(zSpieler);
+			return 1;
+		}
+	}
+	return 0;
 }
 
-void BLTeam::update( Team *zTeam )
+void BLTeam::update(Team* zTeam)
 {
-    rahmen->setFarbe( zTeam->farbe );
-    name->setSchriftFarbe( zTeam->farbe );
-    name->setText( zTeam->name );
-    punkte->setSchriftFarbe( zTeam->farbe );
-    Text pt;
-    pt += zTeam->punkte;
-    pt += "/";
-    pt += zTeam->maxPunkte;
-    punkte->setText( pt );
+	rahmen->setFarbe(zTeam->farbe);
+	name->setSchriftFarbe(zTeam->farbe);
+	name->setText(zTeam->name);
+	punkte->setSchriftFarbe(zTeam->farbe);
+	Text pt;
+	pt += zTeam->punkte;
+	pt += "/";
+	pt += zTeam->maxPunkte;
+	punkte->setText(pt);
 }
 
-void BLTeam::render( int y, Bild &zRObj )
+void BLTeam::render(int y, Bild& zRObj)
 {
-    rahmen->setSize( 422, 21 + 20 * spielerAnzahl );
-    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-        return;
-    rahmen->render( zRObj );
-    name->render( zRObj );
-    punkte->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 = 0x80000000;
-        tmp = 0x80000000;
-        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 != 0x80000000 )
-        {
-            gemahlt->set( 1, tmp );
-            spieler->z( tmp )->render( 20 + 20 * h, zRObj );
-        }
-        else
-            break;
-    }
-    gemahlt->release();
-    zRObj.releaseDrawOptions();
+	rahmen->setSize(422, 21 + 20 * spielerAnzahl);
+	if (!zRObj.setDrawOptions(1, y, rahmen->getBreite(), rahmen->getHeight()))
+		return;
+	rahmen->render(zRObj);
+	name->render(zRObj);
+	punkte->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 = 0x80000000;
+		tmp = 0x80000000;
+		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 != 0x80000000)
+		{
+			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
 {
-    Text *tmp = punkte->zText()->getTeilText( 0, punkte->zText()->positionVon( '/' ) );
-    int ret = *tmp;
-    tmp->release();
-    return ret;
+	Text* tmp = punkte->zText()->getTeilText(0, punkte->zText()->positionVon('/'));
+	int ret = (int)*tmp;
+	tmp->release();
+	return ret;
 }
 
 int BLTeam::getHeight() const
 {
-    return 21 + spielerAnzahl * 20;
+	return 21 + spielerAnzahl * 20;
 }
 
 // Inhalt der Bestenliste Klasse aus Bestenliste.h
 // Konstruktor
-Bestenliste::Bestenliste( UIInit &uiFactory )
-    : ReferenceCounter()
+Bestenliste::Bestenliste(UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    this->uiFactory = uiFactory;
-    rahmen = new LRahmen();
-    rahmen->setRamenBreite( 1 );
-    rahmen->setFarbe( 0xFFFFFFFF );
-    rahmen->setSize( 440, 200 );
-
-    teams = new RCArray< BLTeam >();
-
-    name = uiFactory.createTextFeld( uiFactory.initParam );
-    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-    name->setText( "Name" );
-    name->setSize( 100, 30 );
-    name->setPosition( 0, 0 );
-
-    punkte = uiFactory.createTextFeld( uiFactory.initParam );
-    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-    punkte->setText( "Punkte" );
-    punkte->setSize( 50, 30 );
-    punkte->setPosition( 100, 0 );
-
-    kills = uiFactory.createTextFeld( uiFactory.initParam );
-    kills->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-    kills->setText( "Kills" );
-    kills->setSize( 40, 30 );
-    kills->setPosition( 150, 0 );
-
-    tode = uiFactory.createTextFeld( uiFactory.initParam );
-    tode->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-    tode->setText( "Tode" );
-    tode->setSize( 40, 30 );
-    tode->setPosition( 190, 0 );
-
-    schadenGemacht = uiFactory.createTextFeld( uiFactory.initParam );
-    schadenGemacht->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
-    schadenGemacht->setText( "Schaden\ngemacht" );
-    schadenGemacht->setSize( 60, 30 );
-    schadenGemacht->setPosition( 230, 0 );
-
-    schadenGenommen = uiFactory.createTextFeld( uiFactory.initParam );
-    schadenGenommen->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
-    schadenGenommen->setText( "Schaden\ngenommen" );
-    schadenGenommen->setSize( 60, 30 );
-    schadenGenommen->setPosition( 290, 0 );
-
-    präzision = uiFactory.createTextFeld( uiFactory.initParam );
-    präzision->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
-    präzision->setText( "präzision" );
-    präzision->setSize( 70, 30 );
-    präzision->setPosition( 350, 0 );
-
-    scroll = new VScrollBar();
-    scroll->setKlickScroll( 7 );
-
-    sichtbar = 0;
-    teamAnzahl = 0;
+	this->uiFactory = uiFactory;
+	rahmen = new LRahmen();
+	rahmen->setRamenBreite(1);
+	rahmen->setFarbe(0xFFFFFFFF);
+	rahmen->setSize(440, 200);
+
+	teams = new RCArray< BLTeam >();
+
+	name = uiFactory.createTextFeld(uiFactory.initParam);
+	name->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center);
+	name->setText("Name");
+	name->setSize(100, 30);
+	name->setPosition(0, 0);
+
+	punkte = uiFactory.createTextFeld(uiFactory.initParam);
+	punkte->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center);
+	punkte->setText("Punkte");
+	punkte->setSize(50, 30);
+	punkte->setPosition(100, 0);
+
+	kills = uiFactory.createTextFeld(uiFactory.initParam);
+	kills->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center);
+	kills->setText("Kills");
+	kills->setSize(40, 30);
+	kills->setPosition(150, 0);
+
+	tode = uiFactory.createTextFeld(uiFactory.initParam);
+	tode->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center);
+	tode->setText("Tode");
+	tode->setSize(40, 30);
+	tode->setPosition(190, 0);
+
+	schadenGemacht = uiFactory.createTextFeld(uiFactory.initParam);
+	schadenGemacht->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig);
+	schadenGemacht->setText("Schaden\ngemacht");
+	schadenGemacht->setSize(60, 30);
+	schadenGemacht->setPosition(230, 0);
+
+	schadenGenommen = uiFactory.createTextFeld(uiFactory.initParam);
+	schadenGenommen->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig);
+	schadenGenommen->setText("Schaden\ngenommen");
+	schadenGenommen->setSize(60, 30);
+	schadenGenommen->setPosition(290, 0);
+
+	präzision = uiFactory.createTextFeld(uiFactory.initParam);
+	präzision->setStyle(TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig);
+	präzision->setText("präzision");
+	präzision->setSize(70, 30);
+	präzision->setPosition(350, 0);
+
+	scroll = new VScrollBar();
+	scroll->setKlickScroll(7);
+
+	sichtbar = 0;
+	teamAnzahl = 0;
 }
 
 // Destruktor
 Bestenliste::~Bestenliste()
 {
-    rahmen->release();
-    teams->release();
-    name->release();
-    punkte->release();
-    kills->release();
-    tode->release();
-    schadenGemacht->release();
-    schadenGenommen->release();
-    präzision->release();
-    scroll->release();
+	rahmen->release();
+	teams->release();
+	name->release();
+	punkte->release();
+	kills->release();
+	tode->release();
+	schadenGemacht->release();
+	schadenGenommen->release();
+	präzision->release();
+	scroll->release();
 }
 
 // nicht constant
-void Bestenliste::setTeamAnzahl( int anz )
+void Bestenliste::setTeamAnzahl(int anz)
 {
-    teamAnzahl = anz;
+	teamAnzahl = anz;
 }
 
-void Bestenliste::addSpieler( Spieler *zSpieler )
+void Bestenliste::addSpieler(Spieler* zSpieler)
 {
-    int team = zSpieler->zTeam()->id;
-    if( team < 0 )
-        return;
-    if( !teams->z( team ) )
-        teams->set( new BLTeam( team, uiFactory ), team );
-    teams->z( team )->addSpieler( zSpieler );
+	int team = zSpieler->zTeam()->id;
+	if (team < 0)
+		return;
+	if (!teams->z(team))
+		teams->set(new BLTeam(team, uiFactory), team);
+	teams->z(team)->addSpieler(zSpieler);
 }
 
-void Bestenliste::updateSpieler( Spieler *zSpieler )
+void Bestenliste::updateSpieler(Spieler* zSpieler)
 {
-    if( teams->z( zSpieler->zTeam()->id ) )
-        teams->z( zSpieler->zTeam()->id )->updateSpieler( zSpieler );
+	if (teams->z(zSpieler->zTeam()->id))
+		teams->z(zSpieler->zTeam()->id)->updateSpieler(zSpieler);
 }
 
-void Bestenliste::updateTeam( Team *zTeam )
+void Bestenliste::updateTeam(Team* zTeam)
 {
-    if( teams->z( zTeam->id ) )
-        teams->z( zTeam->id )->update( zTeam );
+	if (teams->z(zTeam->id))
+		teams->z(zTeam->id)->update(zTeam);
 }
 
-void Bestenliste::doTastaturEreignis( TastaturEreignis &te )
+void Bestenliste::doTastaturEreignis(TastaturEreignis& te)
 {
-    if( te.id == TE_Press && te.taste == T_Tab )
-        sichtbar = !sichtbar;
+	if (te.id == TE_Press && te.taste == T_Tab)
+		sichtbar = !sichtbar;
 }
 
-void Bestenliste::doPublicMausEreignis( MausEreignis &me )
+void Bestenliste::doPublicMausEreignis(MausEreignis& me)
 {
-    if( !sichtbar )
-        return;
-    scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
+	if (!sichtbar)
+		return;
+	scroll->doMausMessage(rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me);
 }
 
-void Bestenliste::render( Bild &zRObj )
+void Bestenliste::render(Bild& zRObj)
 {
-    if( !sichtbar )
-        return;
-    if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
-        return;
-    rahmen->render( zRObj );
-    zRObj.alphaRegion( 1, 1, rahmen->getBreite() - 2, rahmen->getHeight() - 2, 0xA0000000 );
-    zRObj.addScrollOffset( 0, scroll->getScroll() );
-    name->render( zRObj );
-    punkte->render( zRObj );
-    kills->render( zRObj );
-    tode->render( zRObj );
-    schadenGemacht->render( zRObj );
-    schadenGenommen->render( zRObj );
-    präzision->render( zRObj );
-    int yOff = 30;
-    Array< bool > *gemahlt = new Array< bool >();
-    for( int i = 1; 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 + 1 ) )
-                continue;
-            if( gemahlt->hat( i + 1 ) && gemahlt->get( i + 1 ) )
-                continue;
-            int p = teams->z( i + 1 )->getPunkte();
-            if( p > min )
-            {
-                min = p;
-                tmp = i + 1;
-            }
-        }
-        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 (!sichtbar)
+		return;
+	if (!zRObj.setDrawOptions(0, 0, rahmen->getBreite(), rahmen->getHeight()))
+		return;
+	rahmen->render(zRObj);
+	zRObj.alphaRegion(1, 1, rahmen->getBreite() - 2, rahmen->getHeight() - 2, 0xA0000000);
+	zRObj.addScrollOffset(0, scroll->getScroll());
+	name->render(zRObj);
+	punkte->render(zRObj);
+	kills->render(zRObj);
+	tode->render(zRObj);
+	schadenGemacht->render(zRObj);
+	schadenGenommen->render(zRObj);
+	präzision->render(zRObj);
+	int yOff = 30;
+	Array< bool >* gemahlt = new Array< bool >();
+	for (int i = 1; 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 + 1))
+				continue;
+			if (gemahlt->hat(i + 1) && gemahlt->get(i + 1))
+				continue;
+			int p = teams->z(i + 1)->getPunkte();
+			if (p > min)
+			{
+				min = p;
+				tmp = i + 1;
+			}
+		}
+		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
+bool Bestenliste::teamExistiert(int team) const
 {
-    return teams->z( team ) != 0;
+	return teams->z(team) != 0;
 }
 
-int Bestenliste::getTeamPunkte( int team ) const
+int Bestenliste::getTeamPunkte(int team) const
 {
-    return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
+	return teams->z(team) ? teams->z(team)->getPunkte() : 0;
 }

Asteroids/Spiel/Chat/Chat.cpp

@@ -9,133 +9,133 @@
 
 // Inhalt der SpielChat Klasse aus Chat.h
 // Konstruktor
-SpielChat::SpielChat( UIInit &uiFactory )
-    : ReferenceCounter()
+SpielChat::SpielChat(UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    rahmen = new LRahmen();
-    rahmen->setFarbe( 0xFF909090 );
-    rahmen->setRamenBreite( 1 );
-    rahmen->setSize( 450, 200 );
-    verlauf = uiFactory.createTextFeld( uiFactory.initParam );
-    verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund ) );
-    verlauf->setText( "" );
-    verlauf->setSize( 446, 174 );
-    nachricht = uiFactory.createTextFeld( uiFactory.initParam );
-    nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
-    nachricht->setText( "Drücke TAB um die Bestenliste anzuzeigen.\n" );
-    nachricht->setSchriftFarbe( 0xFF909090 );
-    nachricht->setRahmenBreite( 1 );
-    nachricht->setRahmenFarbe( 0xFF909090 );
-    nachricht->setSize( 446, 20 );
+	rahmen = new LRahmen();
+	rahmen->setFarbe(0xFF909090);
+	rahmen->setRamenBreite(1);
+	rahmen->setSize(450, 200);
+	verlauf = uiFactory.createTextFeld(uiFactory.initParam);
+	verlauf->setStyle(TextFeld::Style::TextGebiet & ~(TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund));
+	verlauf->setText("");
+	verlauf->setSize(446, 174);
+	nachricht = uiFactory.createTextFeld(uiFactory.initParam);
+	nachricht->setStyle(TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered);
+	nachricht->setText("Drücke TAB um die Bestenliste anzuzeigen.\n");
+	nachricht->setSchriftFarbe(0xFF909090);
+	nachricht->setRahmenBreite(1);
+	nachricht->setRahmenFarbe(0xFF909090);
+	nachricht->setSize(446, 20);
 }
 
 // Destruktor
 SpielChat::~SpielChat()
 {
-    rahmen->release();
-    verlauf->release();
-    nachricht->release();
+	rahmen->release();
+	verlauf->release();
+	nachricht->release();
 }
 
 // nicht constant
-void SpielChat::addNachricht( char *nachricht )
+void SpielChat::addNachricht(const char* nachricht)
 {
-    verlauf->addZeile( nachricht, 0xFFFFFFFF );
-    verlauf->updateVScroll();
+	verlauf->addZeile(nachricht, 0xFFFFFFFF);
+	verlauf->updateVScroll();
 }
 
-void SpielChat::addNachricht( char *nachricht, int farbe )
+void SpielChat::addNachricht(const char* nachricht, int farbe)
 {
-    verlauf->addZeile( nachricht, farbe );
-    verlauf->updateVScroll();
+	verlauf->addZeile(nachricht, farbe);
+	verlauf->updateVScroll();
 }
 
-void SpielChat::doPublicMausEreignis( MausEreignis &me )
+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 )
+void SpielChat::doTastaturEreignis(TastaturEreignis& te, KSGClient::SpielServerClient* zKlient)
 {
-    if( te.taste == T_Esc )
-        nachricht->removeStyle( TextFeld::Style::Fokus );
-    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 = 8;
-                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.taste == T_Esc)
+		nachricht->removeStyle(TextFeld::Style::Fokus);
+	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 = 8;
+				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 )
+void SpielChat::tick(double z)
 {
-    nachricht->tick( z );
+	nachricht->tick(z);
 }
 
-void SpielChat::render( Bild &zRObj )
+void SpielChat::render(Bild& zRObj)
 {
-    rahmen->setPosition( Punkt( 10, zRObj.getHeight() - 210 ) );
-    verlauf->setPosition( rahmen->getX() + 2, rahmen->getY() + 2 );
-    nachricht->setPosition( rahmen->getX() + 2, rahmen->getY() + 178 );
-    rahmen->render( zRObj );
-    verlauf->render( zRObj );
-    nachricht->render( zRObj );
+	rahmen->setPosition(Punkt(10, zRObj.getHeight() - 210));
+	verlauf->setPosition(rahmen->getX() + 2, rahmen->getY() + 2);
+	nachricht->setPosition(rahmen->getX() + 2, rahmen->getY() + 178);
+	rahmen->render(zRObj);
+	verlauf->render(zRObj);
+	nachricht->render(zRObj);
 }
 
 // constant
 bool SpielChat::istAktiv() const
 {
-    return nachricht->hatStyle( TextFeld::Style::Fokus );
+	return nachricht->hatStyle(TextFeld::Style::Fokus);
 }

Asteroids/Spiel/Chat/Chat.h

@@ -11,24 +11,24 @@ using namespace Framework;
 class SpielChat : public virtual ReferenceCounter
 {
 private:
-    LRahmen *rahmen = 0;
-    TextFeld *verlauf;
-    TextFeld *nachricht;
+	LRahmen* rahmen = 0;
+	TextFeld* verlauf;
+	TextFeld* nachricht;
 
 public:
-    // Konstruktor
-    SpielChat( UIInit &uiFactory );
-    // Destruktor
-    ~SpielChat();
-    // nicht constant
-    void addNachricht( char *nachricht );
-    void addNachricht( char *nachricht, int farbe );
-    void doPublicMausEreignis( MausEreignis &me );
-    void doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient );
-    void tick( double z );
-    void render( Bild &zRObj );
-    // constant
-    bool istAktiv() const;
+	// Konstruktor
+	SpielChat(UIInit& uiFactory);
+	// Destruktor
+	~SpielChat();
+	// nicht constant
+	void addNachricht(const char* nachricht);
+	void addNachricht(const char* nachricht, int farbe);
+	void doPublicMausEreignis(MausEreignis& me);
+	void doTastaturEreignis(TastaturEreignis& te, KSGClient::SpielServerClient* zKlient);
+	void tick(double z);
+	void render(Bild& zRObj);
+	// constant
+	bool istAktiv() const;
 };
 
 #endif

Asteroids/Spiel/Karte/Strukturen.cpp

@@ -4,146 +4,145 @@
 
 // Inhalt der RessourceStr Klasse aus Strukturen.h
 // Konstruktor
-RessourceStr::RessourceStr( Datei *zDatei, int karteId, Text *zGamePath )
-    : ReferenceCounter()
+RessourceStr::RessourceStr(Datei* zDatei, int karteId, Text* zGamePath)
+	: ReferenceCounter()
 {
-    zDatei->lese( (char *)&id, 4 );
-    char län = 0;
-    zDatei->lese( &län, 1 );
-    Text txt;
-    txt.fillText( '0', län + 1 );
-    zDatei->lese( txt, län );
-    txt.getText()[ län ] = 0;
-    pfad = 0;
-    if( txt.positionVon( "spiel:" ) == 0 )
-    {
-        pfad = new Text( zGamePath->getText() );
-        if( pfad )
-            pfad->append( txt.getTeilText( 6 ) );
-    }
-    if( txt.positionVon( "map:" ) == 0 )
-    {
-        pfad = new Text( "data/tmp/Karten/" );
-        pfad->append( karteId );
-        pfad->append( "/spiel/files" );
-        pfad->append( txt.getTeilText( 4 ) );
-    }
-    m2d = 0;
-    bild = 0;
-    if( pfad && pfad->hat( ".m2/" ) )
-    {
-        int pos = pfad->positionVon( ".m2/", pfad->anzahlVon( ".m2/" ) - 1 );
-        M2Datei *datei = new M2Datei( pfad->getTeilText( 0, pos + 3 ) );
-        datei->leseDaten();
-        m2d = datei->ladeModel( pfad->getTeilText( pos + 4 ) );
-        datei->release();
-    }
-    if( pfad && pfad->hat( ".ltdb/" ) )
-    {
-        int pos = pfad->positionVon( ".ltdb/", pfad->anzahlVon( ".ltdb/" ) - 1 );
-        LTDBDatei *datei = new LTDBDatei();
-        datei->setDatei( pfad->getTeilText( 0, pos + 5 ) );
-        datei->leseDaten( 0 );
-        bild = datei->laden( 0, pfad->getTeilText( pos + 6 ) );
-        datei->release();
-    }
+	zDatei->lese((char*)&id, 4);
+	char län = 0;
+	zDatei->lese(&län, 1);
+	Text txt;
+	txt.fillText('0', län);
+	zDatei->lese((char*)txt.getText(), län);
+	pfad = 0;
+	if (txt.positionVon("spiel:") == 0)
+	{
+		pfad = new Text(zGamePath->getText());
+		if (pfad)
+			pfad->append(txt.getTeilText(6));
+	}
+	if (txt.positionVon("map:") == 0)
+	{
+		pfad = new Text("data/tmp/Karten/");
+		pfad->append(karteId);
+		pfad->append("/spiel/files");
+		pfad->append(txt.getTeilText(4));
+	}
+	m2d = 0;
+	bild = 0;
+	if (pfad && pfad->hat(".m2/"))
+	{
+		int pos = pfad->positionVon(".m2/", pfad->anzahlVon(".m2/") - 1);
+		M2Datei* datei = new M2Datei(pfad->getTeilText(0, pos + 3));
+		datei->leseDaten();
+		m2d = datei->ladeModel(pfad->getTeilText(pos + 4));
+		datei->release();
+	}
+	if (pfad && pfad->hat(".ltdb/"))
+	{
+		int pos = pfad->positionVon(".ltdb/", pfad->anzahlVon(".ltdb/") - 1);
+		LTDBDatei* datei = new LTDBDatei();
+		datei->setDatei(pfad->getTeilText(0, pos + 5));
+		datei->leseDaten(0);
+		bild = datei->laden(0, pfad->getTeilText(pos + 6));
+		datei->release();
+	}
 }
 
 // Destruktor
 RessourceStr::~RessourceStr()
 {
-    if( pfad )
-        pfad->release();
-    if( m2d )
-        m2d->release();
-    if( bild )
-        bild->release();
+	if (pfad)
+		pfad->release();
+	if (m2d)
+		m2d->release();
+	if (bild)
+		bild->release();
 }
 
 // constant
 int RessourceStr::getId() const
 {
-    return id;
+	return id;
 }
 
-Model2DData *RessourceStr::zReccourceM2() const
+Model2DData* RessourceStr::zReccourceM2() const
 {
-    return m2d;
+	return m2d;
 }
 
-Bild *RessourceStr::zReccourceTxt() const
+Bild* RessourceStr::zReccourceTxt() const
 {
-    return bild;
+	return bild;
 }
 
 
 // Inhalt der ZeichnungStr Klasse aus Strukturen.h
 // Konstruktor
-ObjektStr::ObjektStr( Datei *zDatei )
-    : ReferenceCounter()
+ObjektStr::ObjektStr(Datei* zDatei)
+	: ReferenceCounter()
 {
-    zDatei->lese( (char *)&pos.x, 4 );
-    zDatei->lese( (char *)&pos.y, 4 );
-    zDatei->lese( (char *)&rot, 4 );
-    zDatei->lese( (char *)&scale, 4 );
-    zDatei->lese( (char *)&id, 4 );
-    zDatei->lese( (char *)&m2d, 4 );
-    zDatei->lese( (char *)&bild, 4 );
-    zDatei->lese( (char *)&style, 4 );
-    zDatei->lese( (char *)&maxStabilität, 4 );
-    zDatei->lese( (char *)&maxEnergie, 4 );
-    zDatei->lese( (char *)&energieRadius, 4 );
-    zDatei->lese( (char *)&reparatur, 8 );
-    zDatei->lese( (char *)&akkuLeistung, 8 );
-    zDatei->lese( &team, 1 );
+	zDatei->lese((char*)&pos.x, 4);
+	zDatei->lese((char*)&pos.y, 4);
+	zDatei->lese((char*)&rot, 4);
+	zDatei->lese((char*)&scale, 4);
+	zDatei->lese((char*)&id, 4);
+	zDatei->lese((char*)&m2d, 4);
+	zDatei->lese((char*)&bild, 4);
+	zDatei->lese((char*)&style, 4);
+	zDatei->lese((char*)&maxStabilität, 4);
+	zDatei->lese((char*)&maxEnergie, 4);
+	zDatei->lese((char*)&energieRadius, 4);
+	zDatei->lese((char*)&reparatur, 8);
+	zDatei->lese((char*)&akkuLeistung, 8);
+	zDatei->lese(&team, 1);
 }
 
 
 // Inhalt der SpielerStr Klasse aus Strukturen.h
 // Konstruktor
-SpielerStr::SpielerStr( Datei *zDatei )
-    : ReferenceCounter()
+SpielerStr::SpielerStr(Datei* zDatei)
+	: ReferenceCounter()
 {
-    zDatei->lese( (char *)&id, 4 );
-    zDatei->lese( (char *)&pos.x, 4 );
-    zDatei->lese( (char *)&pos.y, 4 );
-    zDatei->lese( (char *)&rot, 8 );
-    zDatei->lese( (char *)&beschleunigung, 8 );
-    zDatei->lese( (char *)&maxStabilität, 4 );
-    zDatei->lese( (char *)&maxEnergie, 4 );
-    zDatei->lese( (char *)&reparatur, 8 );
-    zDatei->lese( (char *)&akkuLeistung, 8 );
-    zDatei->lese( (char *)&laserIntensität, 4 );
-    zDatei->lese( (char *)&laserEffizienz, 4 );
-    zDatei->lese( (char *)&laserTempo, 4 );
-    zDatei->lese( (char *)&wendigkeit, 8 );
-    zDatei->lese( (char *)&antriebEffizienz, 8 );
-    zDatei->lese( (char *)&energieSchild, 8 );
-    zDatei->lese( (char *)&energieSchildEffizienz, 8 );
-    zDatei->lese( (char *)&netzwerk, 4 );
-    zDatei->lese( (char *)&skillPunkte, 4 );
-    zDatei->lese( (char *)&m2d, 4 );
-    zDatei->lese( (char *)&bild, 4 );
+	zDatei->lese((char*)&id, 4);
+	zDatei->lese((char*)&pos.x, 4);
+	zDatei->lese((char*)&pos.y, 4);
+	zDatei->lese((char*)&rot, 8);
+	zDatei->lese((char*)&beschleunigung, 8);
+	zDatei->lese((char*)&maxStabilität, 4);
+	zDatei->lese((char*)&maxEnergie, 4);
+	zDatei->lese((char*)&reparatur, 8);
+	zDatei->lese((char*)&akkuLeistung, 8);
+	zDatei->lese((char*)&laserIntensität, 4);
+	zDatei->lese((char*)&laserEffizienz, 4);
+	zDatei->lese((char*)&laserTempo, 4);
+	zDatei->lese((char*)&wendigkeit, 8);
+	zDatei->lese((char*)&antriebEffizienz, 8);
+	zDatei->lese((char*)&energieSchild, 8);
+	zDatei->lese((char*)&energieSchildEffizienz, 8);
+	zDatei->lese((char*)&netzwerk, 4);
+	zDatei->lese((char*)&skillPunkte, 4);
+	zDatei->lese((char*)&m2d, 4);
+	zDatei->lese((char*)&bild, 4);
 }
 
 // Inhalt der TeamStr Klasse aus Strukturen.h
 // Konstruktor
-TeamStr::TeamStr( Datei *zDatei )
-    : ReferenceCounter()
+TeamStr::TeamStr(Datei* zDatei)
+	: ReferenceCounter()
 {
-    zDatei->lese( (char *)&id, 4 );
-    zDatei->lese( (char *)&maxPunkte, 4 );
-    zDatei->lese( (char *)&beschleunigung, 8 );
-    zDatei->lese( (char *)&maxStabilität, 4 );
-    zDatei->lese( (char *)&maxEnergie, 4 );
-    zDatei->lese( (char *)&reparatur, 8 );
-    zDatei->lese( (char *)&akkuLeistung, 8 );
-    zDatei->lese( (char *)&laserIntensität, 4 );
-    zDatei->lese( (char *)&laserEffizienz, 4 );
-    zDatei->lese( (char *)&laserTempo, 4 );
-    zDatei->lese( (char *)&wendigkeit, 8 );
-    zDatei->lese( (char *)&antriebEffizienz, 8 );
-    zDatei->lese( (char *)&energieSchild, 8 );
-    zDatei->lese( (char *)&energieSchildEffizienz, 8 );
-    zDatei->lese( (char *)&punkte, 4 );
+	zDatei->lese((char*)&id, 4);
+	zDatei->lese((char*)&maxPunkte, 4);
+	zDatei->lese((char*)&beschleunigung, 8);
+	zDatei->lese((char*)&maxStabilität, 4);
+	zDatei->lese((char*)&maxEnergie, 4);
+	zDatei->lese((char*)&reparatur, 8);
+	zDatei->lese((char*)&akkuLeistung, 8);
+	zDatei->lese((char*)&laserIntensität, 4);
+	zDatei->lese((char*)&laserEffizienz, 4);
+	zDatei->lese((char*)&laserTempo, 4);
+	zDatei->lese((char*)&wendigkeit, 8);
+	zDatei->lese((char*)&antriebEffizienz, 8);
+	zDatei->lese((char*)&energieSchild, 8);
+	zDatei->lese((char*)&energieSchildEffizienz, 8);
+	zDatei->lese((char*)&punkte, 4);
 }

Asteroids/Spiel/Team/Team.cpp

@@ -3,147 +3,147 @@
 
 // Inhalt der Team Klasse aus Team.h
 // Konstruktor
-Team::Team( int f, char* n, TeamStr* zStr )
-    : ReferenceCounter()
+Team::Team(int f, const char* n, TeamStr* zStr)
+	: ReferenceCounter()
 {
-    id = zStr->id;
-    farbe = f;
-    name = n;
-    spieler = new RCArray< Spieler >();
-    punkte = zStr->punkte;
-    maxPunkte = zStr->maxPunkte;
-    maxEnergieS = zStr->maxEnergie;
-    maxStabilitätS = zStr->maxStabilität;
-    reparaturS = zStr->reparatur;
-    laserIntensitätS = zStr->laserIntensität;
-    laserEffizienzS = zStr->laserEffizienz;
-    akkuLeistungS = zStr->akkuLeistung;
-    laserTempoS = zStr->laserTempo;
-    beschleunigungS = zStr->beschleunigung;
-    wendigkeitS = zStr->wendigkeit;
-    antriebEffizienzS = zStr->antriebEffizienz;
-    energieSchildS = zStr->energieSchild;
-    energieSchildEffizienzS = zStr->energieSchildEffizienz;
-    reset();
+	id = zStr->id;
+	farbe = f;
+	name = n;
+	spieler = new RCArray< Spieler >();
+	punkte = zStr->punkte;
+	maxPunkte = zStr->maxPunkte;
+	maxEnergieS = zStr->maxEnergie;
+	maxStabilitätS = zStr->maxStabilität;
+	reparaturS = zStr->reparatur;
+	laserIntensitätS = zStr->laserIntensität;
+	laserEffizienzS = zStr->laserEffizienz;
+	akkuLeistungS = zStr->akkuLeistung;
+	laserTempoS = zStr->laserTempo;
+	beschleunigungS = zStr->beschleunigung;
+	wendigkeitS = zStr->wendigkeit;
+	antriebEffizienzS = zStr->antriebEffizienz;
+	energieSchildS = zStr->energieSchild;
+	energieSchildEffizienzS = zStr->energieSchildEffizienz;
+	reset();
 }
 
 // Destruktor
 Team::~Team()
 {
-    spieler->release();
+	spieler->release();
 }
 
 // nicht constant
 void Team::reset()
 {
-    spieler->leeren();
-    maxEnergie = maxEnergieS;
-    maxStabilität = maxStabilitätS;
-    reparatur = reparaturS;
-    laserIntensität = laserIntensitätS;
-    laserEffizienz = laserEffizienzS;
-    akkuLeistung = akkuLeistungS;
-    laserTempo = laserTempoS;
-    beschleunigung = beschleunigungS;
-    wendigkeit = wendigkeitS;
-    antriebEffizienz = antriebEffizienzS;
-    energieSchild = energieSchildS;
-    energieSchildEffizienz = energieSchildEffizienzS;
+	spieler->leeren();
+	maxEnergie = maxEnergieS;
+	maxStabilität = maxStabilitätS;
+	reparatur = reparaturS;
+	laserIntensität = laserIntensitätS;
+	laserEffizienz = laserEffizienzS;
+	akkuLeistung = akkuLeistungS;
+	laserTempo = laserTempoS;
+	beschleunigung = beschleunigungS;
+	wendigkeit = wendigkeitS;
+	antriebEffizienz = antriebEffizienzS;
+	energieSchild = energieSchildS;
+	energieSchildEffizienz = energieSchildEffizienzS;
 }
 
 // constant
 double Team::getMaxEnergieBonus() const
 {
-    double ret = maxEnergieS;
-    for( auto i : *spieler )
-        ret += i->getTeamMaxEnergieBonus();
-    return ret;
+	double ret = maxEnergieS;
+	for (auto i : *spieler)
+		ret += i->getTeamMaxEnergieBonus();
+	return ret;
 }
 
 double Team::getMaxStabilitätBonus() const
 {
-    double ret = maxStabilitätS;
-    for( auto i : *spieler )
-        ret += i->getTeamMaxStabilitätBonus();
-    return ret;
+	double ret = maxStabilitätS;
+	for (auto i : *spieler)
+		ret += i->getTeamMaxStabilitätBonus();
+	return ret;
 }
 
 double Team::getReperaturBonus() const
 {
-    double ret = reparaturS;
-    for( auto i : *spieler )
-        ret += i->getTeamReparaturBonus();
-    return ret;
+	double ret = reparaturS;
+	for (auto i : *spieler)
+		ret += i->getTeamReparaturBonus();
+	return ret;
 }
 
 double Team::getLaserIntensitätBonus() const
 {
-    double ret = laserIntensitätS;
-    for( auto i : *spieler )
-        ret += i->getTeamLaserIntensitätBonus();
-    return ret;
+	double ret = laserIntensitätS;
+	for (auto i : *spieler)
+		ret += i->getTeamLaserIntensitätBonus();
+	return ret;
 }
 
 double Team::getLaserEffizienzBonus() const
 {
-    double ret = laserEffizienzS;
-    for( auto i : *spieler )
-        ret += i->getTeamLaserEffizienzBonus();
-    return ret;
+	double ret = laserEffizienzS;
+	for (auto i : *spieler)
+		ret += i->getTeamLaserEffizienzBonus();
+	return ret;
 }
 
 double Team::getAkkuLeistungBonus() const
 {
-    double ret = akkuLeistungS;
-    for( auto i : *spieler )
-        ret += i->getTeamAkkuLeistungBonus();
-    return ret;
+	double ret = akkuLeistungS;
+	for (auto i : *spieler)
+		ret += i->getTeamAkkuLeistungBonus();
+	return ret;
 }
 
 double Team::getLaserTempoBonus() const
 {
-    double ret = laserTempoS;
-    for( auto i : *spieler )
-        ret += i->getTeamLaserTempoBonus();
-    return ret;
+	double ret = laserTempoS;
+	for (auto i : *spieler)
+		ret += i->getTeamLaserTempoBonus();
+	return ret;
 }
 
 double Team::getBeschleunigungBonus() const
 {
-    double ret = beschleunigungS;
-    for( auto i : *spieler )
-        ret += i->getTeamBeschleunigungBonus();
-    return ret;
+	double ret = beschleunigungS;
+	for (auto i : *spieler)
+		ret += i->getTeamBeschleunigungBonus();
+	return ret;
 }
 
 double Team::getWendigkeitBonus() const
 {
-    double ret = wendigkeitS;
-    for( auto i : *spieler )
-        ret += i->getTeamWendigkeitBonus();
-    return ret;
+	double ret = wendigkeitS;
+	for (auto i : *spieler)
+		ret += i->getTeamWendigkeitBonus();
+	return ret;
 }
 
 double Team::getAntriebEffizienzBonus() const
 {
-    double ret = antriebEffizienzS;
-    for( auto i : *spieler )
-        ret += i->getTeamAntriebEffizienzBonus();
-    return ret;
+	double ret = antriebEffizienzS;
+	for (auto i : *spieler)
+		ret += i->getTeamAntriebEffizienzBonus();
+	return ret;
 }
 
 double Team::getEnergieSchildBonus() const
 {
-    double ret = energieSchildS;
-    for( auto i : *spieler )
-        ret += i->getTeamEnergieSchildBonus();
-    return ret;
+	double ret = energieSchildS;
+	for (auto i : *spieler)
+		ret += i->getTeamEnergieSchildBonus();
+	return ret;
 }
 
 double Team::getEnergieSchildEffizienzBonus() const
 {
-    double ret = energieSchildEffizienzS;
-    for( auto i : *spieler )
-        ret += i->getTeamEnergieSchildEffizienzBonus();
-    return ret;
+	double ret = energieSchildEffizienzS;
+	for (auto i : *spieler)
+		ret += i->getTeamEnergieSchildEffizienzBonus();
+	return ret;
 }

Asteroids/Spiel/Team/Team.h

@@ -11,58 +11,58 @@ using namespace Framework;
 class Team : public virtual ReferenceCounter
 {
 private:
-    double maxEnergieS;
-    double maxStabilitätS;
-    double reparaturS;
-    double laserIntensitätS;
-    double laserEffizienzS;
-    double akkuLeistungS;
-    double laserTempoS;
-    double beschleunigungS;
-    double wendigkeitS;
-    double antriebEffizienzS;
-    double energieSchildS;
-    double energieSchildEffizienzS;
+	double maxEnergieS;
+	double maxStabilitätS;
+	double reparaturS;
+	double laserIntensitätS;
+	double laserEffizienzS;
+	double akkuLeistungS;
+	double laserTempoS;
+	double beschleunigungS;
+	double wendigkeitS;
+	double antriebEffizienzS;
+	double energieSchildS;
+	double energieSchildEffizienzS;
 
 public:
-    // variablen
-    int id;
-    int farbe;
-    Text name;
-    RCArray< Spieler > *spieler;
-    int punkte;
-    int maxPunkte;
-    double maxEnergie;
-    double maxStabilität;
-    double reparatur;
-    double laserIntensität;
-    double laserEffizienz;
-    double akkuLeistung;
-    double laserTempo;
-    double beschleunigung;
-    double antriebEffizienz;
-    double energieSchild;
-    double energieSchildEffizienz;
-    double wendigkeit;
-    // Konstruktor
-    Team( int f, char *n, TeamStr *zStr );
-    // Destruktor
-    ~Team();
-    // nicht constant
-    void reset();
-    // constant
-    double getMaxEnergieBonus() const;
-    double getMaxStabilitätBonus() const;
-    double getReperaturBonus() const;
-    double getLaserIntensitätBonus() const;
-    double getLaserEffizienzBonus() const;
-    double getAkkuLeistungBonus() const;
-    double getLaserTempoBonus() const;
-    double getBeschleunigungBonus() const;
-    double getAntriebEffizienzBonus() const;
-    double getEnergieSchildBonus() const;
-    double getEnergieSchildEffizienzBonus() const;
-    double getWendigkeitBonus() const;
+	// variablen
+	int id;
+	int farbe;
+	Text name;
+	RCArray< Spieler >* spieler;
+	int punkte;
+	int maxPunkte;
+	double maxEnergie;
+	double maxStabilität;
+	double reparatur;
+	double laserIntensität;
+	double laserEffizienz;
+	double akkuLeistung;
+	double laserTempo;
+	double beschleunigung;
+	double antriebEffizienz;
+	double energieSchild;
+	double energieSchildEffizienz;
+	double wendigkeit;
+	// Konstruktor
+	Team(int f, const char* n, TeamStr* zStr);
+	// Destruktor
+	~Team();
+	// nicht constant
+	void reset();
+	// constant
+	double getMaxEnergieBonus() const;
+	double getMaxStabilitätBonus() const;
+	double getReperaturBonus() const;
+	double getLaserIntensitätBonus() const;
+	double getLaserEffizienzBonus() const;
+	double getAkkuLeistungBonus() const;
+	double getLaserTempoBonus() const;
+	double getBeschleunigungBonus() const;
+	double getAntriebEffizienzBonus() const;
+	double getEnergieSchildBonus() const;
+	double getEnergieSchildEffizienzBonus() const;
+	double getWendigkeitBonus() const;
 };
 
 #endif