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

#include "ObjektOptionen.h"
#include "../../../../Initialisierung/Initialisierung.h"
#include <Textur2D.h>

using namespace Editor;

ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
    : RightTool()
{
    dialog = 0;
    dialog2 = 0;
    this->daten = daten;
    schrift = zSchrift->getThis();
    objekte = new AuswahlListe();
    objekte->setStyle( ( AuswahlListe::Style::Normal & ~AuswahlListe::Style::FeldHAlpha ) | AuswahlBox::Style::VScroll );
    objekte->setRahmenFarbe( 0xFFFFFFFF );
    objekte->setRahmenBreite( 1 );
    objekte->setSchriftZ( zSchrift->getThis() );
    objekte->setSize( 290, 200 );
    objekte->setAAFFarbe( 0x5500FF00 );
    objekte->setAAFStrength( -5 );
    objekte->setALRFarbe( 0xFF00FF00 );
    objekte->setALRBreite( 1 );
    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, zSchrift, Knopf::Style::Normal, "Neues Objekt erstellen" );
    neuesObjekt->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
    {
        if( me.id == ME_RLinks )
        {
            cs.lock();
            if( dialog )
                dialog->release();
            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_MODEL2D, (KarteDaten *)this->daten->getThis(), [ this ]( const char *modelPath )
            {
                if( !modelPath )
                    return;
                cs.lock();
                if( dialog2 )
                    dialog2->release();
                dialog2 = dialog;
                dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_TEXTUR, (KarteDaten *)this->daten->getThis(), [ this, modelPath ]( const char *texturPath )
                {
                    if( !texturPath )
                        return;
                    this->daten->getResourceIdFromPath( modelPath, [ this, texturPath ]( int id )
                    {
                        ObjektDaten o = ObjektDaten();
                        o.m2d = id;
                        this->daten->getResourceIdFromPath( texturPath, [ this, &o ]( int id )
                        {
                            o.bild = id;
                            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, zSchrift, Knopf::Style::Normal, "Model ändern" );
    changeModel->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
    {
        if( me.id == ME_RLinks )
        {
            cs.lock();
            if( dialog )
                dialog->release();
            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_MODEL2D, (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, zSchrift, Knopf::Style::Normal, "Textur ändern" );
    changeTextur->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
    {
        if( me.id == ME_RLinks )
        {
            cs.lock();
            if( dialog )
                dialog->release();
            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_TEXTUR, (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, zSchrift, TextFeld::Style::Text, "Stabilität: " );
    stabilität = initTextFeld( 100, 545, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    energieT = initTextFeld( 0, 570, 100, 20, zSchrift, TextFeld::Style::Text, "Energie: " );
    energie = initTextFeld( 100, 570, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    energieRadiusT = initTextFeld( 0, 595, 100, 20, zSchrift, TextFeld::Style::Text, "Radius: " );
    energieRadius = initTextFeld( 100, 595, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    reparaturT = initTextFeld( 0, 620, 100, 20, zSchrift, TextFeld::Style::Text, "Reparatur: " );
    reparatur = initTextFeld( 100, 620, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    akkuLeistungT = initTextFeld( 0, 645, 100, 20, zSchrift, TextFeld::Style::Text, "Akku: " );
    akkuLeistung = initTextFeld( 100, 645, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    team = initAuswahlBox( 0, 670, 150, 20, zSchrift, 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, zSchrift, KontrollKnopf::Style::Normal, "Verwundbar" );
    beweglich = initKontrollKnopf( 150, 695, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Beweglich" );
    collision = initKontrollKnopf( 0, 720, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Kollision" );
    laserCollision = initKontrollKnopf( 150, 720, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Laser Kollision" );
    neutral = initKontrollKnopf( 0, 745, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Neutral" );
    erfahrung = initKontrollKnopf( 150, 745, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Treffer Erfahrung" );
    speichern = initKnopf( 0, 770, 100, 20, zSchrift, 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;
                    o->update();
                } );
            } );
        }
        return 1;
    } );
    löschen = initKnopf( 105, 770, 100, 20, zSchrift, Knopf::Style::Normal, "Löschen" );
    löschen->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
    {
        if( me.id == ME_RLinks )
        {
            this->daten->removeObjekt( this->daten->getObjektIndexById( *objekte->zEintrag( objekte->getAuswahl() )->zText() ) );
            selectObject( 0 );
        }
        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();
    speichern->release();
    löschen->release();
    daten->release();
    schrift->release();
}

void ObjektTool::doMausEreignis( MausEreignis & me )
{
    bool vera = me.verarbeitet;
    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
        me.verarbeitet = 1;
    Punkt tmpM( me.mx, me.my );
    me.mx = me.rmx;
    me.my = me.rmy;
    cs.lock();
    if( dialog )
        dialog->doMausEreignis( me );
    cs.unlock();
    me.mx = tmpM.x;
    me.my = tmpM.y;
    me.mx -= pos.x;
    me.my -= pos.y;
    team->doMausEreignis( me );
    int ausw = objekte->getAuswahl();
    objekte->doMausEreignis( me );
    if( objekte->getAuswahl() != ausw && objekte->getAuswahl() >= 0 )
        selectObject( *objekte->zEintrag( objekte->getAuswahl() )->zText() );
    if( objekte->getAuswahl() != ausw && objekte->getAuswahl() < 0 )
        selectObject( 0 );
    neuesObjekt->doMausEreignis( me );
    model->doMausEreignis( me );
    changeModel->doMausEreignis( me );
    changeTextur->doMausEreignis( me );
    stabilität->doMausEreignis( me );
    energie->doMausEreignis( me );
    energieRadius->doMausEreignis( me );
    reparatur->doMausEreignis( me );
    akkuLeistung->doMausEreignis( me );
    verwundbar->doMausEreignis( me );
    beweglich->doMausEreignis( me );
    collision->doMausEreignis( me );
    laserCollision->doMausEreignis( me );
    neutral->doMausEreignis( me );
    erfahrung->doMausEreignis( me );
    speichern->doMausEreignis( me );
    löschen->doMausEreignis( me );
    me.mx += pos.x;
    me.my += pos.y;
    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
        me.verarbeitet = vera;
    RightTool::doMausEreignis( me );
}

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

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 |= speichern->tick( tickVal );
    rend |= löschen->tick( tickVal );
    return RightTool::tick( tickVal );
}

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 );
        speichern->render( rObj );
        löschen->render( rObj );
        team->render( rObj );
        rObj.releaseDrawOptions();
    }
}

void ObjektTool::renderDialogs( Bild & rObj )
{
    cs.lock();
    if( dialog )
        dialog->render( rObj );
    cs.unlock();
}

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 );
        speichern->removeStyle( M2DVorschau::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 );
        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 );
        speichern->addStyle( M2DVorschau::Style::Sichtbar );
    }
}