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

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

using namespace Editor;

TeamTool::TeamTool( Schrift *zSchrift, KarteDaten *daten )
    : RightTool()
{
    int teamAnzahl = daten->getTeamAnzahl();
    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal, {} );
    for( int i = 0; i < teamAnzahl; i++ )
    {
        teamAuswahl->addEintrag( new Text( Text( "Team " ) += ( i + 1 ) ) );
    }
    teamAuswahl->setEventAktion( [ this ]( void *p, AuswahlBox *a, int old, int auswahl )
    {
        this->selectTeam( 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" );
    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, zSchrift, TextFeld::Style::Text, "Energie Schild" );
    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, zSchrift, TextFeld::Style::Text, "Schild Effizienz" );
    const TeamDaten *Team = daten->getTeam( daten->getTeamIndexById( 1 ) );
    skillStartStabilität = initTextFeld( 200, 55, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->maxStabilität ) );
    skillStartEnergie = initTextFeld( 200, 80, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->maxEnergie ) );
    skillStartReparatur = initTextFeld( 200, 105, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->reparatur ) );
    skillStartAkku = initTextFeld( 200, 130, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->akkuLeistung ) );
    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->wendigkeit ) );
    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->beschleunigung ) );
    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->antriebEffizienz ) );
    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserIntensität ) );
    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserEffizienz ) );
    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserTempo ) );
    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->energieSchild ) );
    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->energieSchildEffizienz ) );
    speichern = initKnopf( 0, 380, 100, 20, zSchrift, 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();
}

void TeamTool::doMausEreignis( MausEreignis &me )
{
    bool vera = me.verarbeitet;
    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
        me.verarbeitet = 1;
    me.mx -= pos.x;
    me.my -= pos.y;
    teamAuswahl->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 );
    skillStartEnergieSchildT->doMausEreignis( me );
    skillStartEnergieSchildEffizienzT->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 );
    skillStartEnergieSchild->doMausEreignis( me );
    skillStartEnergieSchildEffizienz->doMausEreignis( me );
    bool verarbeitet = me.verarbeitet;
    speichern->doMausEreignis( 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();
        daten->getTeam( daten->getTeamIndexById( teamAuswahl->getAuswahl() + 1 ), [ data ]( TeamDaten *daten ) -> bool
        {
            *daten = data;
            return 1;
        } );
    }
    me.mx += pos.x;
    me.my += pos.y;
    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
        me.verarbeitet = vera;
}

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 );
}

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;
}

void TeamTool::render( Bild &rObj )
{
    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
        return;
    if( rObj.setDrawOptions( pos, gr ) )
    {
        teamAuswahl->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 );
        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 );
        rObj.releaseDrawOptions();
    }
}

void TeamTool::selectTeam( int id )
{
    int index = daten->getTeamIndexById( id );
    teamAuswahl->setAuswahl( id - 1 );
    const 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 ) );
}