Asteroids-Minigame/Asteroids/Map.cpp

#include "Map.h"
#include <InitDatei.h>
#include <Datei.h>
#include <Text.h>
#include <M2Datei.h>
#include <DateiSystem.h>
#include <TastaturEreignis.h>
#include <KSGTDatei.h>
#include <Zeit.h>
#include <Rahmen.h>
#include <Globals.h>
#include <AsynchronCall.h>
#include <Animation.h>

// Inhalt der Map Klasse aus Map.h
// Konstruktor
Map::Map( KSGClient::MinigameServerClient *klient )
    : GameData( "data/Minigames/Asteroids/models/ship.m2", "data/Minigames/Asteroids/models/asteroids.m2" )
{
    kamera = new Kamera2D();
    kamera->setWelt( dynamic_cast<Welt2D *>( world->getThis() ), 1 );
    kamera->setSize( 800, 500 );
    mapKamera = new Kamera2D();
    mapKamera->setWelt( dynamic_cast<Welt2D *>( world->getThis() ), 0 );
    this->klient = klient;
    aTextur = new Bild * [ 7 ]();
    sTextur = new Bild * [ 2 ]();
    // lade Flammen animation
    LTDBDatei flammenStartLTDB;
    flammenStartLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_start.ltdb" ) );
    flammenStartLTDB.leseDaten( 0 );
    Animation2DData *flammenStart = new Animation2DData();
    flammenStart->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenStartLTDB.getThis() ) );
    flammenStart->setFPS( 60 );
    flammenStart->setWiederhohlend( 0 );
    LTDBDatei flammenLTDB;
    flammenLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_burn.ltdb" ) );
    Animation2DData *flammenBurn = new Animation2DData();
    flammenBurn->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenLTDB.getThis() ) );
    flammenBurn->setFPS( 60 );
    flammenBurn->setWiederhohlend( 1 );
    flammenM = new Textur2D();
    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart->getThis() ) );
    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn->getThis() ) );
    flammenL = new Textur2D();
    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart->getThis() ) );
    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn->getThis() ) );
    flammenR = new Textur2D();
    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart ) );
    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn ) );
    LTDBDatei td;
    td.setDatei( new Text( "data/Minigames/Asteroids/bilder/asteroids.ltdb" ) );
    td.leseDaten( 0 );
    for( int i = 0; i < 7; i++ )
    {
        Text name = "";
        name.append( (char)( 'a' + i ) );
        aTextur[ i ] = td.laden( 0, new Text( (char *)( Text( name ) += ".png" ) ) );
    }
    td.setDatei( new Text( "data/Minigames/Asteroids/bilder/ship.ltdb" ) );
    td.leseDaten( 0 );
    for( int i = 0; i < 2; i++ )
    {
        Text name = "";
        name.append( (char)( 'a' + i ) );
        sTextur[ i ] = td.laden( 0, new Text( (char *)( Text( name ) += ".png" ) ) );
    }
    map = new LRahmen();
    map->setFarbe( 0xFFFFFFFF );
    map->setPosition( 10, 10 );
    map->setSize( 200, 200 );
    mapKamera->setPosition( 10, 10 );
    mapKamera->setSize( 200, 200 );
    autoKam = 0;
}

// Destruktor
Map::~Map()
{
    for( int i = 0; i < 7; i++ )
        aTextur[ i ]->release();
    for( int i = 0; i < 2; i++ )
        sTextur[ i ]->release();
    delete[] aTextur;
    delete[] sTextur;
    map->release();
    if( klient )
        klient->release();
    flammenM->release();
    flammenL->release();
    flammenR->release();
    if( kamera )
        kamera->release();
    if( mapKamera )
        mapKamera->release();
}

Asteroid *Map::createNewAsteroid()
{
    Asteroid *a = __super::createNewAsteroid();
    if( a )
    {
        Textur2D *text = new Textur2D();
        text->setTexturZ( dynamic_cast<Bild *>( aTextur[ a->getId() ]->getThis() ) );
        a->setTextur( text );
    }
    return a;
}

// nicht constant
void Map::reset( Text *zOptionen )
{
    flammenL->setAnimation( -1 );
    flammenR->setAnimation( -1 );
    flammenM->setAnimation( -1 );
    __super::reset( zOptionen );
    world->setSize( breite, höhe );
    world->setSize( 1 );
    world->setCircular( 1 );
    Text *tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 5 ) + 1, zOptionen->positionVon( ',', 5 ) );
    bool fortsetzen = (int)*tmp != 0;
    tmp->release();
    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 6 ) + 1, zOptionen->positionVon( ',', 6 ) > 0 ? zOptionen->positionVon( ',', 6 ) : zOptionen->getLength() );
    autoKam = (int)*tmp != 0;
    if( !autoKam )
        kamera->setDrehung( 0 );
    tmp->release();
    if( fortsetzen && DateiExistiert( "data/Minigames/Asteroids/data/game.save" ) && klient )
    {
        M2Datei sad;
        int index = 0;
        int sadI = 0;
        Text pfad = "data/Minigames/Asteroids/data/sasave_";
        pfad += sadI;
        pfad += ".m2";
        sad.setPfad( pfad );
        sad.leseDaten();
        if( capture.istOffen() )
            capture.close();
        capture.setDatei( "data/Minigames/Asteroids/data/game.mgc" );
        capture.open( Datei::Style::schreiben | Datei::Style::ende | Datei::Style::lesen );
        Datei *save = new Datei();
        save->setDatei( "data/Minigames/Asteroids/data/game.save" );
        save->open( Datei::Style::lesen );
        int br = 0;
        int hö = 0;
        int gr = 0;
        int shn = 0;
        __int64 seed;
        if( rGen )
            rGen = (RandomGenerator *)rGen->release();
        save->lese( (char *)&seed, 8 );
        rGen = new RandomGenerator();
        rGen->setSeed( seed );
        save->lese( (char *)&gameTime, 8 );
        save->lese( (char *)&br, 4 );
        save->lese( (char *)&hö, 4 );
        save->lese( (char *)&gr, 4 );
        save->lese( (char *)&shn, 4 );
        if( br == breite && hö == höhe && gr == aGröße && shn == shipN )
        {
            save->lese( (char *)&score, 4 );
            scoreCheck = score * 11197;
            save->lese( (char *)&mTimer, 4 );
            // Schiff laden
            Vec2< float > shipPos( (float)( breite / 2 ), (float)( höhe / 2 ) );
            Vec2< float > shipSpeed( 0, 0 );
            float shipR = (float)-PI / 2;
            float shipRSpeed = 0;
            save->lese( (char *)&shipPos.x, 4 );
            save->lese( (char *)&shipPos.y, 4 );
            save->lese( (char *)&shipSpeed.x, 4 );
            save->lese( (char *)&shipSpeed.y, 4 );
            save->lese( (char *)&shipR, 4 );
            save->lese( (char *)&shipRSpeed, 4 );
            ship->setPRS( shipPos, shipSpeed, shipR, shipRSpeed );
            int anz = 0;
            save->lese( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            { // Asteroiden Laden
                char n = 0;
                float x = 0;
                float y = 0;
                float xs = 0;
                float ys = 0;
                float rs = 0;
                float r = 0;
                float gr = 0;
                save->lese( &n, 1 );
                save->lese( (char *)&x, 4 );
                save->lese( (char *)&y, 4 );
                save->lese( (char *)&xs, 4 );
                save->lese( (char *)&ys, 4 );
                save->lese( (char *)&rs, 4 );
                save->lese( (char *)&r, 4 );
                save->lese( (char *)&gr, 4 );
                Bild *at = 0;
                Model2DData *ad = 0;
                if( n < 0 )
                {
                    at = dynamic_cast<Bild *>( aTextur[ -n - 1 ]->getThis() );
                    ad = sad.ladeModel( sad.zModelName( index++ )->getText() );
                    if( index == 120 )
                    {
                        index = 0;
                        sadI++;
                        Text pfad = "data/Minigames/Asteroids/data/sasave_";
                        pfad += sadI;
                        pfad += ".m2";
                        sad = M2Datei();
                        sad.setPfad( pfad );
                        sad.leseDaten();
                    }
                }
                else
                {
                    at = dynamic_cast<Bild *>( aTextur[ n ]->getThis() );
                    ad = dynamic_cast<Model2DData *>( aData[ n ]->getThis() );
                }
                asteroid->add( new Asteroid( ad, at,
                                             Vec2< float >( x, y ), Vec2< float >( xs, ys ), rs, r, gr, n ) );
            }
            save->lese( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            { // Schüsse Laden
                float x = 0;
                float y = 0;
                float xs = 0;
                float ys = 0;
                save->lese( (char *)&x, 4 );
                save->lese( (char *)&y, 4 );
                save->lese( (char *)&xs, 4 );
                save->lese( (char *)&ys, 4 );
                if( schuss->getEintragAnzahl() > 100 )
                {
                    Schuss *newS = new Schuss( Vec2< float >( x, y ), Vec2< float >( xs, ys ) );
                    schuss->add( newS );
                    world->addObject( dynamic_cast<Object2D *>( newS->getThis() ) );
                }
            }
        }
        save->close();
        save->release();
    }
    else
    {
        if( klient )
        {
            if( capture.istOffen() )
                capture.close();
            DateiRemove( "data/Minigames/Asteroids/data/game.mgc" );
            capture.setDatei( "data/Minigames/Asteroids/data/game.mgc" );
            capture.erstellen();
            capture.open( Datei::Style::schreiben );
            __int64 seed = rGen->getSeed();
            capture.schreibe( (char *)&seed, 8 );
        }
    }
    ship->setTexture( flammenM, flammenL, flammenR, dynamic_cast<Bild *>( sTextur[ shipN ]->getThis() ) );
}

void Map::doPublicMausEreignis( MausEreignis &me )
{}

void Map::doTastaturEreignis( TastaturEreignis &te )
{
    cs.lock();
    bool ok = 1;
    if( !beendet )
    {
        char tmp = tastenStände;
        if( te.taste == 'w' || te.taste == 'W' || te.taste == T_Oben )
        {
            if( te.id == TE_Press )
            {
                if( ( tastenStände | 1 ) != tastenStände )
                    flammenM->setAnimation( 0 );
                tastenStände |= 1;
            }
            else
            {
                tastenStände &= ~1;
                flammenM->setAnimation( -1 );
            }
        }
        if( te.taste == 'd' || te.taste == 'D' || te.taste == T_Rechts )
        {
            if( te.id == TE_Press )
            {
                if( ( tastenStände | 2 ) != tastenStände )
                    flammenL->setAnimation( 0 );
                tastenStände |= 2;
            }
            else
            {
                tastenStände &= ~2;
                flammenL->setAnimation( -1 );
            }
        }
        if( te.taste == 'a' || te.taste == 'A' || te.taste == T_Links )
        {
            if( te.id == TE_Press )
            {
                if( ( tastenStände | 4 ) != tastenStände )
                    flammenR->setAnimation( 0 );
                tastenStände |= 4;
            }
            else
            {
                tastenStände &= ~4;
                flammenR->setAnimation( -1 );
            }
        }
        if( te.taste == T_Space )
        {
            if( te.id == TE_Press )
            {
                if( ( tastenStände | 8 ) != tastenStände )
                    ok = 0;
                tastenStände |= 8;
            }
            else
                tastenStände &= ~8;
        }
        if( tmp != tastenStände && klient )
        {
            if( klient )
            {
                capture.schreibe( (char *)&gameTime, 8 );
                capture.schreibe( &tastenStände, 1 );
            }
        }
    }
    if( te.taste == T_Space && te.id == TE_Press )
    {
        if( klient && ok )
        {
            capture.schreibe( (char *)&gameTime, 8 );
            capture.schreibe( "\x10", 1 );
        }
        if( schuss->getEintragAnzahl() < 100 )
        {
            Schuss *newS = ship->getSchuss();
            schuss->add( newS );
            world->addObject( dynamic_cast<Object2D *>( newS->getThis() ) );
        }
    }
    cs.unlock();
}

bool Map::tick( double t )
{
    if( beendet )
        return 0;
    bool ret = __super::tick( t );
    ret |= kamera->tick( t );
    if( beendet && klient )
    {
        capture.close();
        DateiRemove( "data/Minigames/Asteroids/data/upload.mgc" );
        DateiUmbenennen( "data/Minigames/Asteroids/data/game.mgc", "data/Minigames/Asteroids/data/upload.mgc" );
        int tmpScore = score;
        KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
        new AsynchronCall( [tmpScore, tmpKlient]()
        {
            InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
            opd->laden();
            Text optionen = "Width=";
            optionen += opd->zWert( "Breite" )->getText();
            optionen += ",Height=";
            optionen += opd->zWert( "Höhe" )->getText();
            optionen += ",Size=";
            optionen += opd->zWert( "Größe" )->getText();
            optionen += ",Timer=";
            optionen += opd->zWert( "Timer" )->getText();
            optionen += ",Ship=";
            optionen += opd->zWert( "Ship" )->getText();
            opd->release();
            Datei d;
            d.setDatei( "data/Minigames/Asteroids/data/upload.mgc" );
            tmpKlient->reportEndOfGame( "Asteroids", optionen, tmpScore, &d );
            DateiRemove( "data/Minigames/Asteroids/data/upload.mgc" );
            tmpKlient->release();
        } );
        KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
        if( !stb->laden() )
            DateiPfadErstellen( "data/Minigames/Asteroids/data/score.ksgt" );
        RCArray< Text > *zeile = new RCArray< Text >();
        Zeit *zeit = getZeit();
        zeile->add( zeit->getZeit( "y-m-d h:i:s" ) );
        zeit->release();
        Text *scoreT = new Text();
        scoreT->append( score );
        zeile->add( scoreT );
        Text *breiteT = new Text();
        breiteT->append( breite );
        zeile->add( breiteT );
        Text *höheT = new Text();
        höheT->append( höhe );
        zeile->add( höheT );
        Text *timerT = new Text();
        timerT->append( maxTimer );
        zeile->add( timerT );
        Text *aGrößeT = new Text();
        aGrößeT->append( aGröße );
        zeile->add( aGrößeT );
        Text *shipT = new Text();
        shipT->append( shipN );
        zeile->add( shipT );
        stb->addZeile( 7, zeile );
        zeile->release();
        stb->speichern();
        stb->release();
        DateiRemove( "data/Minigames/Asteroids/data/game.save" );
    }
    ret |= flammenM->tick( t );
    ret |= flammenL->tick( t );
    ret |= flammenR->tick( t );
    return ret;
}

void Map::render( Bild &zRObj )
{
    cs.lock();
    kamera->lookAtWorldPos( ship->getPosition().x, ship->getPosition().y );
    if( autoKam )
        kamera->setDrehung( -ship->getDrehung() );
    kamera->render( zRObj );
    if( breite >= 800 || höhe >= 500 )
    { // Minimap
        zRObj.setAlpha( 50 );
        if( breite > höhe )
            mapKamera->setSize( 200, (int)( ( 200.0 / world->getWorldInfo().size.x ) * world->getWorldInfo().size.y ) );
        else
            mapKamera->setSize( (int)( ( 200.0 / world->getWorldInfo().size.y ) * world->getWorldInfo().size.x ), 200 );
        mapKamera->lookAtWorldPos( world->getWorldInfo().size.x / 2.f, world->getWorldInfo().size.y / 2.f );
        mapKamera->lookAtWorldArea( (float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y );
        mapKamera->render( zRObj );
        map->setSize( mapKamera->getBreite(), mapKamera->getHeight() );
        map->render( zRObj );
        zRObj.releaseAlpha();
    }
    cs.unlock();
}

void Map::speichern()
{
    if( !beendet && klient )
    {
        if( capture.istOffen() )
            capture.close();
        cs.lock();
        int anz = asteroid->getEintragAnzahl();
        int index = 0;
        for( int i = 0; index < anz; i++ )
        {
            M2Datei sad;
            Text pfad = "data/Minigames/Asteroids/data/sasave_";
            pfad += i;
            pfad += ".m2";
            DateiRemove( pfad );
            sad.setPfad( pfad );
            sad.leseDaten();
            char name[ 2 ];
            name[ 1 ] = 0;
            for( char n = 1; n <= 120 && index < anz; n++ )
            {
                name[ 0 ] = n;
                if( asteroid->z( index++ )->getId() < 0 )
                    sad.saveModel( asteroid->z( index - 1 )->zModel(), name );
                else
                    n--;
            }
        }
        Datei *d = new Datei();
        d->setDatei( "data/Minigames/Asteroids/data/game.save" );
        d->erstellen();
        d->open( Datei::Style::schreiben );
        __int64 seed = rGen->getSeed();
        d->schreibe( (char *)&seed, 8 );
        d->schreibe( (char *)&gameTime, 8 );
        d->schreibe( (char *)&breite, 4 );
        d->schreibe( (char *)&höhe, 4 );
        d->schreibe( (char *)&aGröße, 4 );
        d->schreibe( (char *)&shipN, 4 );
        d->schreibe( (char *)&score, 4 );
        d->schreibe( (char *)&mTimer, 4 );
        ship->save( d );
        d->schreibe( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
            asteroid->z( i )->save( d );
        anz = schuss->getEintragAnzahl();
        d->schreibe( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
            schuss->z( i )->save( d );
        d->close();
        d->release();
        cs.unlock();
    }
    else if( klient )
        DateiRemove( "data/Minigames/Asteroids/data/game.save" );
}