Fangen-Minigame/Fangen/Map.cpp

#include "Map.h"
#include <Rahmen.h>
#include <InitDatei.h>
#include <Text.h>
#include <Zeit.h>
#include <KSGTDatei.h>
#include <AsynchronCall.h>
#include <iostream>

// Inhalt der Map Klasse aus Map.h
// Konstruktor
Map::Map( KSGClient::MinigameServerClient *klient )
    : ReferenceCounter()
{
    this->klient = klient;
    gegner = new RCArray< Spieler >();
    ziele = new RCArray< Spieler >();
    spieler = 0;
    feld = new LRahmen();
    feld->setFarbe( 0xFFFFFFFF );
    kam = new LRahmen();
    kam->setFarbe( 0xFF777777 );
    map = new LRahmen();
    map->setFarbe( 0xFFFFFFFF );
    map->setPosition( 10, 10 );
    //map->setSize( 200, 200 );
    beendet = 1;
    gameTime = 0;
    tastenStände = 0;
    rGen = 0;
}

// Destruktor
Map::~Map()
{
    speichern();
    gegner->release();
    ziele->release();
    if( spieler )
        spieler->release();
    feld->release();
    kam->release();
    map->release();
    if( rGen )
        rGen->release();
    if( klient )
        klient->release();
}

// nicht constant
void Map::reset( Text *zOptionen )
{
    gameTime = 0;
    tastenStände = 0;
    if( rGen )
        rGen = (RandomGenerator *)rGen->release();
    beendet = 0;
    score = 0;
    scoreCheck = score * 11197;
    gegner->leeren();
    ziele->leeren();
    if( spieler )
        spieler = (Spieler *)spieler->release();
    ziele->leeren();
    Text *tmp = zOptionen->getTeilText( zOptionen->positionVon( '=' ) + 1, zOptionen->positionVon( ',' ) );
    breite = *tmp;
    tmp->release();
    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 1 ) + 1, zOptionen->positionVon( ',', 1 ) );
    höhe = *tmp;
    tmp->release();
    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 2 ) + 1, zOptionen->positionVon( ',', 2 ) );
    zAnzahl = *tmp;
    tmp->release();
    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 3 ) + 1, zOptionen->positionVon( ',', 3 ) );
    neuGegner = *tmp;
    tmp->release();
    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 4 ) + 1, zOptionen->positionVon( ',', 4 ) );
    geschwindigkeit = *tmp;
    tmp->release();
    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 5 ) + 1, zOptionen->positionVon( ',', 5 ) );
    bool fortsetzen = (int)*tmp != 0;
    tmp->release();
    kamX = 0;
    kamY = 0;
    if( breite > 80 )
        kamX = breite / 2 - 400;
    if( höhe > 50 )
        kamY = höhe / 2 - 250;
    if( fortsetzen && DateiExistiert( "data/Minigames/Fangen/data/game.save" ) && klient )
    {
        if( capture.istOffen() )
            capture.close();
        capture.setDatei( "data/Minigames/Fangen/data/game.mgc" );
        capture.open( Datei::Style::schreiben | Datei::Style::ende | Datei::Style::lesen );
        Datei *save = new Datei();
        save->setDatei( "data/Minigames/Fangen/data/game.save" );
        save->open( Datei::Style::lesen );
        int br = 0;
        int hö = 0;
        __int64 seed;
        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 );
        if( br == breite && hö == höhe )
        {
            save->lese( (char *)&score, 4 );
            scoreCheck = score * 11197;
            spieler = new Spieler( SPIELER, save );
            int anz = 0;
            save->lese( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
                gegner->add( new Spieler( GEGNER, save ) );
            save->lese( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
                ziele->add( new Spieler( ZIEL, save ) );
        }
        save->close();
        save->release();
    }
    else
    {
        rGen = new RandomGenerator();
        if( klient )
        {
            if( capture.istOffen() )
                capture.close();
            DateiRemove( "data/Minigames/Fangen/data/game.mgc" );
            capture.setDatei( "data/Minigames/Fangen/data/game.mgc" );
            capture.erstellen();
            capture.open( Datei::Style::schreiben );
            __int64 seed = rGen->getSeed();
            capture.schreibe( (char *)&seed, 8 );
        }
        else
        {
            tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 6 ) + 1 );
            rGen->setSeed( (__int64)*tmp );
            tmp->release();
        }
    }
    if( !spieler )
        spieler = new Spieler( SPIELER, breite, höhe, rGen );
    if( !gegner->getEintragAnzahl() )
    {
        for( int i = 0; i < neuGegner; i++ )
            gegner->add( new Spieler( GEGNER, breite, höhe, rGen ) );
    }
    if( !ziele->getEintragAnzahl() )
    {
        for( int i = 0; i < zAnzahl; i++ )
            ziele->add( new Spieler( ZIEL, breite, höhe, rGen ) );
    }
}

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 )
                tastenStände |= 1;
            else
                tastenStände &= ~1;
        }
        if( te.taste == 'd' || te.taste == 'D' || te.taste == T_Rechts )
        {
            if( te.id == TE_Press )
                tastenStände |= 2;
            else
                tastenStände &= ~2;
        }
        if( te.taste == 'a' || te.taste == 'A' || te.taste == T_Links )
        {
            if( te.id == TE_Press )
                tastenStände |= 4;
            else
                tastenStände &= ~4;
        }
        if( te.taste == 's' || te.taste == 'S' || te.taste == T_Unten )
        {
            if( te.id == TE_Press )
                tastenStände |= 8;
            else
                tastenStände &= ~8;
        }
        if( tmp != tastenStände && klient )
        {
            if( klient )
            {
                capture.schreibe( (char *)&gameTime, 8 );
                capture.schreibe( &tastenStände, 1 );
            }
        }
    }
    cs.unlock();
}

bool Map::tick( double tickVal )
{
    if( beendet || !spieler )
        return 0;
    if( score * 11197 != scoreCheck )
    {
        beendet = 1;
        score = 0;
        scoreCheck = 0;
    }
    cs.lock();
    gameTime += tickVal;
    double t = tickVal * geschwindigkeit / 1000;
    spieler->tick( t, breite, höhe, tastenStände );
    int anz = gegner->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        gegner->z( i )->tick( t, breite, höhe, tastenStände );
        if( gegner->z( i )->berührt( spieler->getX(), spieler->getY() ) )
            beendet = 1;
    }
    anz = ziele->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        ziele->z( i )->tick( t, breite, höhe, tastenStände );
        if( ziele->z( i )->berührt( spieler->getX(), spieler->getY() ) )
        {
            score++;
            scoreCheck = score * 11197;
            ziele->leeren();
            for( int i = 0; i < zAnzahl; i++ )
                ziele->add( new Spieler( ZIEL, breite, höhe, rGen ) );
            for( int i = 0; i < neuGegner; i++ )
                gegner->add( new Spieler( GEGNER, breite, höhe, rGen ) );
        }
    }
    if( breite > 800 )
    {
        kamX = (int)spieler->getX() - 400;
        if( kamX < 0 )
            kamX = 0;
        if( kamX + 800 > breite )
            kamX = breite - 800;
    }
    if( höhe > 500 )
    {
        kamY = (int)spieler->getY() - 250;
        if( kamY < 0 )
            kamY = 0;
        if( kamY + 500 > höhe )
            kamY = höhe - 500;
    }
    if( beendet && klient )
    {
        capture.close();
        DateiRemove( "data/Minigames/Fangen/data/upload.mgc" );
        DateiUmbenennen( "data/Minigames/Fangen/data/game.mgc", "data/Minigames/Fangen/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/Fangen/data/optionen.ini" );
            opd->laden();
            Text optionen = "Width=";
            optionen += opd->zWert( "Breite" )->getText();
            optionen += ",Height=";
            optionen += opd->zWert( "Höhe" )->getText();
            optionen += ",Ziele=";
            optionen += opd->zWert( "Ziele" )->getText();
            optionen += ",Gegner=";
            optionen += opd->zWert( "+Gegner" )->getText();
            optionen += ",Speed=";
            optionen += opd->zWert( "Geschwindigkeit" )->getText();
            opd->release();
            Datei d;
            d.setDatei( "data/Minigames/Fangen/data/upload.mgc" );
            tmpKlient->reportEndOfGame( "Fangen", optionen, tmpScore, &d );
            DateiRemove( "data/Minigames/Fangen/data/upload.mgc" );
            tmpKlient->release();
        } );
        KSGTDatei *stb = new KSGTDatei( "data/Minigames/Fangen/data/score.ksgt" );
        if( !stb->laden() )
            DateiPfadErstellen( "data/Minigames/Fangen/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 *geschwindigkeitT = new Text();
        geschwindigkeitT->append( geschwindigkeit );
        zeile->add( geschwindigkeitT );
        Text *zAnzahlT = new Text();
        zAnzahlT->append( zAnzahl );
        zeile->add( zAnzahlT );
        Text *nAnzahlT = new Text();
        nAnzahlT->append( neuGegner );
        zeile->add( nAnzahlT );
        stb->addZeile( 7, zeile );
        zeile->release();
        stb->speichern();
        stb->release();
        DateiRemove( "data/Minigames/Fangen/data/game.save" );
    }
    cs.unlock();
    return 1;
}

void Map::render( Bild &zRObj )
{
    if( !spieler )
        return;
    int xStart = 0;
    int yStart = 0;
    if( breite < 800 )
        xStart = 400 - breite / 2;
    else
        xStart -= kamX;
    if( höhe < 500 )
        yStart = 250 - höhe / 2;
    else
        yStart -= kamY;
    feld->setPosition( xStart, yStart );
    feld->setSize( breite, höhe );
    feld->render( zRObj );
    bool rMap = breite > 800 || höhe > 500;
    zRObj.addScrollOffset( -xStart, -yStart );
    spieler->render( zRObj );
    int gAnz = gegner->getEintragAnzahl();
    for( int i = 0; i < gAnz; i++ )
        gegner->z( i )->render( zRObj );
    int zAnz = ziele->getEintragAnzahl();
    for( int i = 0; i < zAnz; i++ )
        ziele->z( i )->render( zRObj );
    zRObj.addScrollOffset( xStart, yStart );
    if( rMap )
    {
        const Punkt &dOff = zRObj.getDrawOff();
        map->render( zRObj );
        zRObj.setPixelDP( 10 + ( 200 * spieler->getX() ) / breite + dOff.x, 10 + ( 200 * spieler->getY() ) / höhe + dOff.y, 0xFF00FF00 );
        for( int i = 0; i < gAnz; i++ )
            zRObj.setPixelDP( 10 + ( 200 * gegner->z( i )->getX() ) / breite + dOff.x, 10 + ( 200 * gegner->z( i )->getY() ) / höhe + dOff.y, 0xFFFF0000 );
        for( int i = 0; i < zAnz; i++ )
            zRObj.setPixelDP( 10 + ( 200 * ziele->z( i )->getX() ) / breite + dOff.x, 10 + ( 200 * ziele->z( i )->getY() ) / höhe + dOff.y, 0xFF00FFFF );
        kam->setPosition( 10 + ( 200 * kamX ) / breite, 10 + ( 200 * kamY ) / höhe );
        kam->setSize( ( 200 * 800 ) / breite, ( 200 * 500 ) / höhe );
        if( kam->getBreite() > 200 )
            kam->setSize( 200, kam->getHeight() );
        if( kam->getHeight() > 200 )
            kam->setSize( kam->getBreite(), 200 );
        kam->render( zRObj );
    }
}

void Map::speichern()
{
    if( !beendet && spieler )
    {
        if( capture.istOffen() )
            capture.close();
        Datei *d = new Datei();
        d->setDatei( "data/Minigames/Fangen/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 *)&score, 4 );
        spieler->save( d );
        int anz = gegner->getEintragAnzahl();
        d->schreibe( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
            gegner->z( i )->save( d );
        anz = ziele->getEintragAnzahl();
        d->schreibe( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
            ziele->z( i )->save( d );
        d->close();
        d->release();
    }
    else if( klient )
        DateiRemove( "data/Minigames/Fangen/data/game.save" );
}

Map::Save *Map::saveState()
{
    Save *s = new Save();
    s->beendet = beendet;
    s->gameTime = gameTime;
    s->score = score;
    s->scoreCheck = scoreCheck;
    s->gegner = new RCArray<Spieler>();
    for( auto g = gegner->getIterator(); g; g++ )
        s->gegner->add( g->copy() );
    s->ziele = new RCArray<Spieler>();
    for( auto z = ziele->getIterator(); z; z++ )
        s->ziele->add( z->copy() );
    s->spieler = spieler->copy();
    return s;
}

void Map::reloadState( Map::Save *s )
{
    beendet = s->beendet;
    gameTime = s->gameTime;
    score = s->score;
    scoreCheck = s->scoreCheck;
    gegner->leeren();
    for( auto g = s->gegner->getIterator(); g; g++ )
        gegner->add( dynamic_cast<Spieler *>( g->getThis() ) );
    ziele->leeren();
    for( auto z = s->ziele->getIterator(); z; z++ )
        ziele->add( dynamic_cast<Spieler *>( z->getThis() ) );
    spieler->release();
    spieler = dynamic_cast<Spieler *>( s->spieler->getThis() );
    s->ziele->release();
    s->gegner->release();
    s->spieler->release();
    delete s;
}

bool Map::canGoLeft() const
{
    return spieler->getX() > 10;
}

bool Map::canGoUp() const
{
    return spieler->getY() > 10;
}

bool Map::canGoRight() const
{
    return spieler->getX() < breite - 10;
}

bool Map::canGoDown() const
{
    return spieler->getY() < höhe - 10;
}


int Map::getBestOption( bool *left, bool *up, bool *right, bool *down, int maxSteps )
{
    if( !maxSteps && !beendet )
        return score;
    else if( beendet )
        return -1;
    int best = 0;
    int maxScore = -2;
    int order[] = { 0, 1, 2, 4, 8, 3, 9, 6, 12 };
    int orderCount = 9;
    for( int x = 0; x < orderCount; x++ )
    {
        int i = order[ x ];
        Save *save = saveState();
        TastaturEreignis te;
        te.taste = T_Links;
        te.verarbeitet = 0;
        te.id = ( i | 0x1 ) == i ? TE_Press : TE_Release;
        doTastaturEreignis( te );
        te.taste = T_Oben;
        te.verarbeitet = 0;
        te.id = ( i | 0x2 ) == i ? TE_Press : TE_Release;
        doTastaturEreignis( te );
        te.taste = T_Rechts;
        te.verarbeitet = 0;
        te.id = ( i | 0x4 ) == i ? TE_Press : TE_Release;
        doTastaturEreignis( te );
        te.taste = T_Unten;
        te.verarbeitet = 0;
        te.id = ( i | 0x8 ) == i ? TE_Press : TE_Release;
        doTastaturEreignis( te );
        tick( 0.05 );
        tick( 0.05 );
        tick( 0.05 );
        tick( 0.05 );
        tick( 0.05 );
        Save *save2 = saveState();
        tick( 0.05 );
        tick( 0.05 );
        tick( 0.05 );
        tick( 0.05 );
        tick( 0.05 );
        if( beendet && !save2->beendet )
        {
            reloadState( save2 );
            save2 = 0;
        }
        int score = getBestOption( left, up, right, down, maxSteps - 1 );
        if( this->score > save->score )
            score += maxSteps;
        if( score > maxScore )
        {
            maxScore = score;
            best = i;
        }
        if( save2 )
            reloadState( save2 );
        reloadState( save );
    }
    *left = ( best | 0x1 ) == best;
    *up = ( best | 0x2 ) == best;
    *right = ( best | 0x4 ) == best;
    *down = ( best | 0x8 ) == best;
    return maxScore;
}

// constant
int Map::getScore() const
{
    return score;
}

bool Map::istBeendet() const
{
    return beendet;
}