Asteroids-Online-Client/Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.cpp

#include "SpielerOptionen.h"
#include "../../../../Initialisierung/Initialisierung.h"
#include "../../../Karte/EditorKarte.h"

using namespace Editor;

SpielerTool::SpielerTool( Schrift *zSchrift, KarteDaten *daten )
    : RightTool()
{
    int spielerAnzahl = daten->getSpielerAnzahl();
    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal, {} );
    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, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, zSchrift, TextFeld::Style::Text, "Stabilität" );
    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, zSchrift, TextFeld::Style::Text, "Energie" );
    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, zSchrift, TextFeld::Style::Text, "Reparatur" );
    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, zSchrift, TextFeld::Style::Text, "Akku" );
    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, zSchrift, TextFeld::Style::Text, "Wendigkeit" );
    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, zSchrift, TextFeld::Style::Text, "Beschleunigung" );
    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, zSchrift, TextFeld::Style::Text, "Antrieb Effizienz" );
    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Intensität" );
    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Effizienz" );
    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Tempo" );
    skillStartNetzwerkT = initTextFeld( 0, 305, 200, 20, zSchrift, TextFeld::Style::Text, "Netzwerk" );
    const SpielerDaten *spieler = daten->getSpieler( daten->getSpielerIndexById( 1 ) );
    skillStartStabilität = initTextFeld( 200, 55, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->maxStabilität ) );
    skillStartEnergie = initTextFeld( 200, 80, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->maxEnergie ) );
    skillStartReparatur = initTextFeld( 200, 105, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->reparatur ) );
    skillStartAkku = initTextFeld( 200, 130, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->akkuLeistung ) );
    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->wendigkeit ) );
    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->beschleunigung ) );
    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->antriebEffizienz ) );
    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserIntensität ) );
    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserEffizienz ) );
    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserTempo ) );
    skillStartNetzwerk = initTextFeld( 200, 305, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->netzwerk ) );
    speichern = initKnopf( 0, 330, 100, 20, zSchrift, 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();
    skillStartNetzwerkT->release();
    skillStartStabilität->release();
    skillStartEnergie->release();
    skillStartReparatur->release();
    skillStartAkku->release();
    skillStartWendigkeit->release();
    skillStartBeschleunigung->release();
    skillStartAntriebEffizienz->release();
    skillStartLaserIntensität->release();
    skillStartLaserEffizienz->release();
    skillStartLaserTempo->release();
    skillStartNetzwerk->release();
    speichern->release();
    daten->release();
}

void SpielerTool::doMausEreignis( MausEreignis &me )
{
    me.mx -= pos.x;
    me.my -= pos.y;
    spielerAuswahl->doMausEreignis( me );
    skillStartT->doMausEreignis( me );
    skillStartStabilitätT->doMausEreignis( me );
    skillStartEnergieT->doMausEreignis( me );
    skillStartReparaturT->doMausEreignis( me );
    skillStartAkkuT->doMausEreignis( me );
    skillStartWendigkeitT->doMausEreignis( me );
    skillStartBeschleunigungT->doMausEreignis( me );
    skillStartAntriebEffizienzT->doMausEreignis( me );
    skillStartLaserIntensitätT->doMausEreignis( me );
    skillStartLaserEffizienzT->doMausEreignis( me );
    skillStartLaserTempoT->doMausEreignis( me );
    skillStartNetzwerkT->doMausEreignis( me );
    skillStartStabilität->doMausEreignis( me );
    skillStartEnergie->doMausEreignis( me );
    skillStartReparatur->doMausEreignis( me );
    skillStartAkku->doMausEreignis( me );
    skillStartWendigkeit->doMausEreignis( me );
    skillStartBeschleunigung->doMausEreignis( me );
    skillStartAntriebEffizienz->doMausEreignis( me );
    skillStartLaserIntensität->doMausEreignis( me );
    skillStartLaserEffizienz->doMausEreignis( me );
    skillStartLaserTempo->doMausEreignis( me );
    skillStartNetzwerk->doMausEreignis( me );
    bool verarbeitet = me.verarbeitet;
    speichern->doMausEreignis( 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.netzwerk = *skillStartNetzwerk->zText();
        daten->getSpieler( daten->getSpielerIndexById( spielerAuswahl->getAuswahl() + 1 ), [ data ]( SpielerDaten *daten ) -> bool
        {
            *daten = data;
            return 1;
        } );
    }
    me.mx += pos.x;
    me.my += pos.y;
}

void SpielerTool::doTastaturEreignis( TastaturEreignis &te )
{
    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 );
    skillStartNetzwerkT->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 );
    skillStartNetzwerk->doTastaturEreignis( te );
    speichern->doTastaturEreignis( te );
}

bool SpielerTool::tick( double 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 |= skillStartNetzwerkT->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 |= skillStartNetzwerk->tick( tickVal );
    ret |= speichern->tick( tickVal );
    return ret;
}

void SpielerTool::render( Bild &rObj )
{
    if( rObj.setDrawOptions( pos, gr ) )
    {
        spielerAuswahl->render( rObj );
        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 );
        skillStartNetzwerkT->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 );
        skillStartNetzwerk->render( rObj );
        speichern->render( rObj );
        rObj.releaseDrawOptions();
    }
}

void SpielerTool::selectPlayer( int id )
{
    int index = daten->getSpielerIndexById( id );
    spielerAuswahl->setAuswahl( id - 1 );
    const 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 ) );
    skillStartNetzwerk->setText( Text( spieler->netzwerk ) );
}