Stickman-World-Online-Client/StickmanWorldOnline/Spiel.cpp

#include "Spiel.h"
#include "Reader.h"

#define TICK 0.03333333

// Konstruktor
Spiel::Spiel()
    : ReferenceCounter()
{
    stkn = new RCArray< STKNachricht >();
    infoKlient = 0;
    spielKlient = 0;
    chat = 0;
    end = 0;
    spielerGUI = 0;
    deads = new RCArray< DeadPlayer >();
    nextId = 0;
    begonnen = 0;
    rZeit = 0;
    gameTicks = 0;
    spielerAnzahl = 0;
    karteId = 0;
    ladenProzent = 0;
    spielerNummer = 0;
    zWinner = 0;
    pause = 1;
    tasten = new char[ 256 ];
    for( int i = 0; i < 256; i++ )
        tasten[ i ] = 0;
    lastRunnedTrigger = 0;
    zuletztEingeschalteteBariere = 0;
    zuletztAusgeschalteteBariere = 0;
    zuletztBewegteBariere = 0;
    lastTeamChangedBase = 0;
    lastDropedDrop = 0;
    zuletztAufgehobenerGegenstand = KEIN_GEGENSTAND;
    zuletztBenutzterGegenstand = KEIN_GEGENSTAND;
    zuletztGedropterGegenstand = KEIN_GEGENSTAND;
    zuletztAbgefeuertesGeschoss = 0;
    zuletztUmgelenktesGeschoss = 0;
    zuletztBariereGetroffenesGeschoss = 0;
    zuletztTunnelBenutztesGeschoss = 0;
    zuletztGeschossGetroffenesGeschoss = 0;
    zuletztAktivierterSchalter = 0;
    zuletztSchadenGemachterSpieler = 0;
    zuletztSchadenGenommenerSpieler = 0;
    zuletztGeheilterSpieler = 0;
    zuletztLevelUpSpieler = 0;
    zuletztErfahrungBekommenerSpieler = 0;
    zuletztGegenstandAktivierterSpieler = 0;
    zuletztGegenstandAufgehobenerSpieler = 0;
    zuletztSchalterAktivierterSpieler = 0;
    zuletztTunnelBenutzterSpieler = 0;
    zuletztGestorbenerSpieler = 0;
    zuletztWiederbelebterSpieler = 0;
    zuletztGeschossenerSpieler = 0;
    zuletztAbgelaufenerTimer = 0;
    zuletztGestarteterTimer = 0;
    zuletztPausierterTimer = 0;
    zuletztFortgesetzterTimer = 0;
    zuletztBenutzterTunnel = 0;
    zuletztBenutzteUmlenkung = 0;
    resources = 0;
    nextAutoVerschiebung = 10;
    nextAutoSchaltung = 10;
}

// Destruktor
Spiel::~Spiel()
{
    stkn->release();
    if( infoKlient )
        infoKlient->release();
    if( spielKlient )
        spielKlient->release();
    if( chat )
        chat->release();
    if( end )
        end->release();
    if( spielerGUI )
        spielerGUI->release();
    deads->release();
    if( lastRunnedTrigger )
        lastRunnedTrigger->release();
    if( zuletztEingeschalteteBariere )
        zuletztEingeschalteteBariere->release();
    if( zuletztAusgeschalteteBariere )
        zuletztAusgeschalteteBariere->release();
    if( zuletztBewegteBariere )
        zuletztBewegteBariere->release();
    if( lastTeamChangedBase )
        lastTeamChangedBase->release();
    if( lastDropedDrop )
        lastDropedDrop->release();
    if( zuletztAbgefeuertesGeschoss )
        zuletztAbgefeuertesGeschoss->release();
    if( zuletztUmgelenktesGeschoss )
        zuletztUmgelenktesGeschoss->release();
    if( zuletztBariereGetroffenesGeschoss )
        zuletztBariereGetroffenesGeschoss->release();
    if( zuletztTunnelBenutztesGeschoss )
        zuletztTunnelBenutztesGeschoss->release();
    if( zuletztGeschossGetroffenesGeschoss )
        zuletztGeschossGetroffenesGeschoss->release();
    if( zuletztAktivierterSchalter )
        zuletztAktivierterSchalter->release();
    if( zuletztSchadenGemachterSpieler )
        zuletztSchadenGemachterSpieler->release();
    if( zuletztSchadenGenommenerSpieler )
        zuletztSchadenGenommenerSpieler->release();
    if( zuletztGeheilterSpieler )
        zuletztGeheilterSpieler->release();
    if( zuletztLevelUpSpieler )
        zuletztLevelUpSpieler->release();
    if( zuletztErfahrungBekommenerSpieler )
        zuletztErfahrungBekommenerSpieler->release();
    if( zuletztGegenstandAktivierterSpieler )
        zuletztGegenstandAktivierterSpieler->release();
    if( zuletztGegenstandAufgehobenerSpieler )
        zuletztGegenstandAufgehobenerSpieler->release();
    if( zuletztSchalterAktivierterSpieler )
        zuletztSchalterAktivierterSpieler->release();
    if( zuletztTunnelBenutzterSpieler )
        zuletztTunnelBenutzterSpieler->release();
    if( zuletztGestorbenerSpieler )
        zuletztGestorbenerSpieler->release();
    if( zuletztWiederbelebterSpieler )
        zuletztWiederbelebterSpieler->release();
    if( zuletztGeschossenerSpieler )
        zuletztGeschossenerSpieler->release();
    if( zuletztAbgelaufenerTimer )
        zuletztAbgelaufenerTimer->release();
    if( zuletztGestarteterTimer )
        zuletztGestarteterTimer->release();
    if( zuletztPausierterTimer )
        zuletztPausierterTimer->release();
    if( zuletztFortgesetzterTimer )
        zuletztFortgesetzterTimer->release();
    if( zuletztBenutzterTunnel )
        zuletztBenutzterTunnel->release();
    if( zuletztBenutzteUmlenkung )
        zuletztBenutzteUmlenkung->release();
    if( resources )
        resources->release();
    delete[] tasten;
}

bool Spiel::istAmLeben() const
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler.z( i )->getId() == spielerNummer )
            return spieler.z( i )->istAmLeben();
    }
    return 0;
}

void Spiel::tick()
{
    double zeit = TICK;
    rZeit -= zeit;// spieler bewegungen
    if( pause )
        zeit = 0;
    nextAutoVerschiebung -= zeit;
    nextAutoSchaltung -= zeit;
    if( nextAutoVerschiebung <= 0 )
    {
        nextAutoVerschiebung += 30 + randG.rand() * 30;
        int anz = 0;
        for( auto b : barieren )
        {
            if( b->hatStyle( Bariere::Style::AutoVerschiebung ) )
                anz++;
        }
        if( anz )
        {
            int rand = (int)(randG.rand() * anz);
            for( auto b : barieren )
            {
                if( b->hatStyle( Bariere::Style::AutoVerschiebung ) )
                {
                    if( rand == 0 )
                    {
                        b->startAutoVerschiebung( this );
                        break;
                    }
                    rand--;
                }
            }
        }
    }
    if( nextAutoSchaltung <= 0 )
    {
        nextAutoSchaltung += 30 + randG.rand() * 30;
        int anz = 0;
        for( auto b : barieren )
        {
            if( b->hatStyle( Bariere::Style::AutoSchaltung ) )
                anz++;
        }
        if( anz )
        {
            int rand = (int)(randG.rand() * anz);
            for( auto b : barieren )
            {
                if( b->hatStyle( Bariere::Style::AutoSchaltung ) )
                {
                    if( rand == 0 )
                    {
                        b->startAutoSchaltung( this );
                        break;
                    }
                    rand--;
                }
            }
        }
    }
    for( int i = 0; i < animations.getEintragAnzahl(); i++ )
    {
        if( animations.z( i )->tick( zeit ) )
            animations.remove( i-- );
    }
    // gegenstand despawn
    for( int i = 0; i < items.getEintragAnzahl(); i++ )
    {
        if( items.z( i )->tick( zeit ) )
        {
            items.remove( i );
            i--;
        }
    }
    Richtung rs[] = { OBEN, RECHTS, UNTEN, LINKS };
    for( auto s : spieler )
    {
        for( Richtung r : rs )
        {
            s->move( r, zeit );
            if( s->getX() < 0 || s->getY() < 0 || s->getX() + s->getWidth() >= mapSize.x || s->getY() + s->getHeight() >= mapSize.y )
                s->move( r, -zeit );
            else
            {
                for( auto b : barieren )
                { // spieler - bariere intersection
                    if( b->hatStyle( Bariere::Style::Aktiv ) && (b->zTeam() != s->zTeam()) && b->intersectsWith( s ) )
                        s->move( r, -zeit );
                }
            }
        }
    }
    for( auto s : spieler )
        s->tick( zeit, this );
    // barieren bewegung
    for( auto b : barieren )
        b->tick( zeit, this );
    // geschoss bewegung
    for( int i = 0; i < shots.getEintragAnzahl(); i++ )
    {
        Geschoss* g = shots.z( i );
        g->tick( zeit );
        bool removed = 0;
        // geschoss - bariere intersection
        bool intersectsWithBariere = 0;
        for( auto b : barieren )
        {
            if( b->hatStyle( Bariere::Style::Aktiv ) && b->intersectsWith( g ) )
            {
                intersectsWithBariere = 1;
                break;
            }
        }
        if( intersectsWithBariere || g->getX() < 0 || g->getY() < 0 || g->getX() + g->getWidth() >= mapSize.x || g->getY() + g->getHeight() >= mapSize.y )
        {
            if( zuletztBariereGetroffenesGeschoss )
                zuletztBariereGetroffenesGeschoss->release();
            zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss*>(g->getThis());
            g->tick( -zeit );
            switch( g->getTyp() )
            {
            case GESCHOSS_PFEIL:
                shots.remove( i );
                i--;
                removed = 1;
                break;
            case GESCHOSS_KUGEL:
            case GESCHOSS_DRACHENAUGE:
                g->invertDirection();
                break;
            case GESCHOSS_FEUERBALL:
                if( intersectsWithBariere )
                {
                    feuer.add( new FeuerballTreffer( resources, ++nextId, (int)g->getX() - (int)g->getWidth() / 2, (int)g->getY() - (int)g->getHeight() / 2, g->getBesitzer(), 10 ) );
                    shots.remove( i );
                    i--;
                    removed = 1;
                }
                else
                    g->invertDirection();
                break;
            case GESCHOSS_MINE:
                for( auto s : spieler )
                {
                    if( s->abstandZu( g ) < 50 )
                    {
                        s->nimmSchaden( 100 - s->abstandZu( g ), g->zBesitzer(), MITTE, this );
                        if( g->zBesitzer() )
                            g->zBesitzer()->addTreffer( this );
                        s->addGetroffen();
                    }
                }
                addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 50, g->getY() + g->getHeight() / 2 - 50, 100, 100, resources->getResource( R_EXPLOSION, 0 ) ) );
                shots.remove( i );
                i--;
                removed = 1;
                break;
            }
        }
        if( !removed )
        { // geschoss - tunnel intersection
            for( auto t : tunnel )
            {
                if( t->istAktiv() && t->intersectsWith( g ) )
                {
                    g->setX( g->getX() + (float)t->getZielX() - t->getX() );
                    g->setY( g->getY() + (float)t->getZielY() - t->getY() );
                    g->addTunnel( this );
                    Ereignis* e = new Ereignis( TUNNEL_BENUTZT );
                    e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss*>(g->getThis()) );
                    e->addParameter( "Betroffer Tunnel", dynamic_cast<Tunnel*>(t->getThis()) );
                    throwEvent( e );
                }
            }
            // geschoss - schalter intersection
            if( g->getTyp() == GESCHOSS_PFEIL )
            {
                for( auto s : schalter )
                {
                    if( s->isAktive() && s->intersectsWith( g ) )
                    {
                        shots.remove( i );
                        i--;
                        removed = 1;
                        g->addSchalter();
                        activateShalter( s->getId() );
                        break;
                    }
                }
            }
            if( !removed )
            {
                // geschoss - umlenkung intersection
                if( g->getTyp() != GESCHOSS_PFEIL )
                {
                    for( auto u : umlenkungen )
                    {
                        if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
                        {
                            g->setRichtung( u->getRichtung() );
                            g->addUmlenkung( this );
                            u->addBenutzt( this );
                            Ereignis* e = new Ereignis( UMLENKUNG_LENKT_UM );
                            e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss*>(g->getThis()) );
                            e->addParameter( "Betroffe Umlenkung", dynamic_cast<Umlenkung*>(u->getThis()) );
                            throwEvent( e );
                        }
                    }
                }
                // geschoss - geschoss intersection
                if( g->getTyp() == GESCHOSS_PFEIL )
                {
                    for( int j = 0; j < shots.getEintragAnzahl(); j++ )
                    {
                        if( i == j )
                            continue;
                        Geschoss* g2 = shots.z( j );
                        if( g2->intersectsWith( g ) )
                        {
                            addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 20, g->getY() + g->getHeight() / 2 - 20, 40, 40, resources->getResource( R_EXPLOSION, 0 ) ) );
                            if( g2->getTyp() == GESCHOSS_PFEIL )
                                removed = 1;
                            g->addGeschossTreffer( this );
                            if( j < i )
                                i--;
                            shots.remove( j );
                            j--;
                        }
                    }
                    if( removed )
                    {
                        shots.remove( i );
                        i--;
                    }
                }
                if( !removed )
                {
                    // geschoss - spieler intersection
                    for( auto s : spieler )
                    {
                        if( s->istAmLeben() && g->intersectsWith( s ) )
                        {
                            switch( g->getTyp() )
                            {
                            case GESCHOSS_PFEIL:
                            {
                                s->nimmSchaden( PFEIL_DAMAGE, g->zBesitzer(), invert( g->getRichtung() ), this );
                                break;
                            }
                            case GESCHOSS_KUGEL:
                            {
                                addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 25, g->getY() + g->getHeight() / 2 - 25, 50, 50, resources->getResource( R_EXPLOSION, 0 ) ) );
                                s->nimmSchaden( KUGEL_DAMAGE, g->zBesitzer(), invert( g->getRichtung() ), this );
                                break;
                            }
                            case GESCHOSS_DRACHENAUGE:
                                addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 25, g->getY() + g->getHeight() / 2 - 25, 50, 50, resources->getResource( R_EXPLOSION, 0 ) ) );
                                s->addEffekt( new DrachenAugeEffect( resources, g->zBesitzer(), s ) );
                                break;
                            case GESCHOSS_FEUERBALL:
                                feuer.add( new FeuerballTreffer( resources, ++nextId, (int)g->getX() - (int)g->getWidth() / 2, (int)g->getY() - (int)g->getHeight() / 2, g->getBesitzer(), 10 ) );
                                break;
                            case GESCHOSS_MINE:
                                addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 50, g->getY() + g->getHeight() / 2 - 50, 100, 100, resources->getResource( R_EXPLOSION, 0 ) ) );
                                for( auto s2 : spieler )
                                {
                                    if( s2->abstandZu( g ) < 50 )
                                    {
                                        s2->nimmSchaden( 100 - s->abstandZu( g ), g->zBesitzer(), MITTE, this );
                                        if( g->zBesitzer() )
                                            g->zBesitzer()->addTreffer( this );
                                        s->addGetroffen();
                                    }
                                }
                                break;
                            }
                            if( g->getTyp() != GESCHOSS_MINE )
                            {
                                if( g->zBesitzer() )
                                    g->zBesitzer()->addTreffer( this );
                                s->addGetroffen();
                            }
                            shots.remove( i );
                            i--;
                            removed = 1;
                            break;
                        }
                    }
                }
            }
        }
    }
    // Feuer Ticks
    for( int i = 0; i < feuer.getEintragAnzahl(); i++ )
    {
        FeuerballTreffer* f = feuer.z( i );
        f->tick( zeit );
        if( f->isOver() )
        {
            feuer.remove( i );
            i--;
            continue;
        }
        if( f->makeDamage() )
        {
            for( auto s : spieler )
            {
                if( s->abstandZu( f ) < f->getWidth() / 2 )
                    s->addEffekt( new BrandEffekt( resources, f->zVerursacher(), s ) );
            }
        }
    }
    // Drop Ticks
    for( auto d : drops )
        d->tick( zeit, this );
    // Timer Ticks
    for( auto t : timer )
        t->tick( zeit, this );
    // Umlenkung Ticks
    for( auto u : umlenkungen )
        u->tick( zeit );
    // Base Ticks
    for( auto b : basen )
        b->tick( zeit, this );
    // aktive trigger Ticks
    for( int i = 0; i < triggerRuns.getEintragAnzahl(); i++ )
    {
        if( !triggerRuns.z( i )->runNext( zeit ) )
        {
            Ereignis* e = new Ereignis( AUSLOESER_RUNNED );
            e->addParameter( "Betroffener Auslöser", triggerRuns.z( i )->getTrigger() );
            throwEvent( e );
            triggerRuns.remove( i );
            i--;
        }
    }
}

Spieler* Spiel::zEigenerSpieler() const
{
    for( auto s : spieler )
    {
        if( s->getId() == spielerNummer )
            return s;
    }
    return 0;
}

Team* Spiel::zEigenesTeam() const
{
    Spieler* s = zEigenerSpieler();
    return s ? s->zTeam() : 0;
}

// nicht constant
void Spiel::lock()
{
    c.lock();
}

void Spiel::unlock()
{
    c.unlock();
}

// call 3
void Spiel::setUIFactory( UIInit& uiFactory )
{
    this->uiFactory = uiFactory;
    chat = new SpielChat( uiFactory );
}

void Spiel::nachricht( int län, char* bytes )
{
    lock();
    stkn->add( new STKNachricht( län, bytes ) );
    unlock();
}

// call 2
void Spiel::setKlients( KSGClient::InformationServerClient* infoKlient, KSGClient::SpielServerClient* spielKlient )
{
    if( this->infoKlient )
        this->infoKlient->release();
    this->infoKlient = infoKlient;
    if( this->spielKlient )
        this->spielKlient->release();
    this->spielKlient = spielKlient;
}

// call 1
void Spiel::setKarteId( int karteId )
{
    this->karteId = karteId;
}

// call 5
void Spiel::ladeDaten()
{
    Sleep( 1000 );
    Text* gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
    Text mapPf = Text( "data/tmp/Karten/" ) + karteId + "/spiel/files";
    // loading resources
    if( resources )
        resources->release();
    resources = new ResourceRegistry( gamePath->getText(), mapPf );
    resources->setUIFactory( uiFactory );
    resources->zResource( R_BARIERE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/bariere.png" );
    resources->zResource( R_BASE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/base.png" );
    resources->zResource( R_PFEIL_GESCHOSS, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/pfeilg.png" );
    resources->zResource( R_PFEIL, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/pfeil.png" );
    resources->zResource( R_LEBEN, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/leben.png" );
    resources->zResource( R_SCHILD, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/schild.png" );
    resources->zResource( R_SCHUH, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/schuh.png" );
    resources->zResource( R_GEIST, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/geist.png" );
    resources->zResource( R_ROLLE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/rolle.png" );
    resources->zResource( R_ROLLE_OBEN, 0, new ColorMode(), "spiel:/bilder/rolleoben.ltdb" );
    resources->zResource( R_ROLLE_LINKS, 0, new ColorMode(), "spiel:/bilder/rollelinks.ltdb" );
    resources->zResource( R_ROLLE_RECHTS, 0, new ColorMode(), "spiel:/bilder/rollerechts.ltdb" );
    resources->zResource( R_ROLLE_UNTEN, 0, new ColorMode(), "spiel:/bilder/rolleunten.ltdb" );
    resources->zResource( R_STURM, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/sturm.png" );
    resources->zResource( R_STURM_OBEN, 0, new ColorMode(), "spiel:/bilder/sturmoben.ltdb" );
    resources->zResource( R_STURM_LINKS, 0, new ColorMode(), "spiel:/bilder/sturmlinks.ltdb" );
    resources->zResource( R_STURM_RECHTS, 0, new ColorMode(), "spiel:/bilder/sturmrechts.ltdb" );
    resources->zResource( R_STURM_UNTEN, 0, new ColorMode(), "spiel:/bilder/sturmunten.ltdb" );
    resources->zResource( R_DRACHENAUGE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/drachenauge.png" );
    resources->zResource( R_DRACHENAUGE_GESCHOSS, 0, new ColorMode(), "spiel:/bilder/drachenauge.ltdb" );
    resources->zResource( R_FEUERBALL, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/feuerball.png" );
    resources->zResource( R_FEUERBALL_GESCHOSS, 0, new ColorMode(), "spiel:/bilder/feuerball.ltdb" );
    resources->zResource( R_FEUERBALL_TREFFER, 0, new ColorMode(), "spiel:/bilder/feuerballtreffer.ltdb" );
    resources->zResource( R_ENTERHAKEN_SEIL, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/enterhakenseil." );
    resources->zResource( R_ENTERHAKEN_SPITZE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/enterhakenspitz" );
    resources->zResource( R_ENTERHAKEN_ITEM, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/enterhaken.png" );
    resources->zResource( R_MINE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/miene.png" );
    resources->zResource( R_MINE_GESCHOSS, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/mieneg.png" );
    resources->zResource( R_RWEISHEIT, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/rweisheit.png" );
    resources->zResource( R_RBOSHEIT, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/rbosheit.png" );
    resources->zResource( R_RLEBEN, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/rleben.png" );
    resources->zResource( R_RTEMPO, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/rtempo.png" );
    resources->zResource( R_RSTRENGTH, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/rstrength.png" );
    resources->zResource( R_SCHALTER, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/schalter.png" );
    resources->zResource( R_SCHIENE, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/schiene.png" );
    resources->zResource( R_SPIELER_STIRBT, 0, new ColorMode(), "spiel:/bilder/spielerstirbt.ltdb" );
    resources->zResource( R_SPIELER, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/spieler.png" );
    resources->zResource( R_SPIELER_RECHTS, 0, new ColorMode(), "spiel:/bilder/spielerrechts.ltdb" );
    resources->zResource( R_SPIELER_LINKS, 0, new ColorMode(), "spiel:/bilder/spielerlinks.ltdb" );
    resources->zResource( R_BRAND, 0, new ColorMode(), "spiel:/bilder/brand.ltdb" );
    resources->zResource( R_EXPLOSION, 0, new ColorMode(), "spiel:/bilder/explosion.ltdb" );
    resources->zResource( R_HEILUNG, 0, new ColorMode(), "spiel:/bilder/heilung.ltdb" );
    resources->zResource( R_SCHADEN, 0, new ColorMode(), "spiel:/bilder/schaden.ltdb" );
    resources->zResource( R_TUNNEL, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/tunnel.png" );
    resources->zResource( R_UMLENKUNG, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/umlenkung.png" );
    resources->zResource( R_RWEISHEIT_EFFECT, 0, new ColorMode(), "spiel:/bilder/rweisheit.ltdb" );
    resources->zResource( R_RBOSHEIT_EFFECT, 0, new ColorMode(), "spiel:/bilder/rbosheit.ltdb" );
    resources->zResource( R_RLEBEN_EFFECT, 0, new ColorMode(), "spiel:/bilder/rleben.ltdb" );
    resources->zResource( R_RTEMPO_EFFECT, 0, new ColorMode(), "spiel:/bilder/rtempo.ltdb" );
    resources->zResource( R_RSTRENGTH_EFFECT, 0, new ColorMode(), "spiel:/bilder/rstrength.ltdb" );
    resources->zResource( R_KUGEL_GESCHOSS, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/kugelg.png" );
    resources->zResource( R_KUGEL, 0, new ColorMode(), "spiel:/bilder/textures.ltdb/kugel.png" );
    resources->zResource( R_GUI_ERF, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/erfleiste.png" );
    resources->zResource( R_GUI_ERF_RAND, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/erfrand.png" );
    resources->zResource( R_GUI_INVENTAR_AUSWAHL, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/invausw.png" );
    resources->zResource( R_GUI_INVENTAR_HINTERGRUND, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/invbg.png" );
    resources->zResource( R_GUI_INVENTAR_HINTERGRUND_BENUTZT, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/invbgdark.png" );
    resources->zResource( R_GUI_LEBEN_RAND, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/lebenrand.png" );
    resources->zResource( R_GUI_LEVEL_RAND, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/levelrand.png" );
    resources->zResource( R_GUI_SPIELER, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/spieler.png" );
    spielKlient->setLadenProzent( 20 );

    MapReader* reader = new MapReader( karteId, Text( "data/tmp/Karten/" ) + karteId + "/spiel/data/" );
    // apply team color filters
    Array<int>* colors = reader->getTeamFarben();
    AlphaColorMode* alphaMode = new AlphaColorMode( 0x77 );
    for( auto c : *colors )
    {
        resources->zResource( R_BARIERE, c, dynamic_cast<AlphaColorMode*>(alphaMode->getThis()) );
        resources->zResource( R_BASE, c, dynamic_cast<AlphaColorMode*>(alphaMode->getThis()) );
    }
    colors->release();
    alphaMode->release();
    spielKlient->setLadenProzent( 35 );
    // apply player color filters
    colors = reader->getSpielerFarben();
    MaskColorMode* maskMode = new MaskColorMode( 0xFFFFFF );
    for( auto c : *colors )
    {
        resources->zResource( R_ROLLE_OBEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_ROLLE_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_ROLLE_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_ROLLE_UNTEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_STURM_OBEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_STURM_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_STURM_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_STURM_UNTEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_SPIELER_STIRBT, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_SPIELER, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_SPIELER_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
        resources->zResource( R_SPIELER_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
    }
    colors->release();
    spielKlient->setLadenProzent( 50 );
    // loading map
    reader->ladeKarte( this );
    spielKlient->setLadenProzent( 99 );
    reader->release();

    spielerGUI = new SpielerGUI( resources );
    maskMode->release();
    spielKlient->setLadenProzent( 100 );
    gamePath->release();
}

void Spiel::doPublicMausEreignis( MausEreignis& me )
{
    if( me.verarbeitet || !begonnen )
        return;
    if( end )
    {
        end->doPublicMausEreignis( me );
        return;
    }
    if( chat )
        chat->doPublicMausEreignis( me );
}

void Spiel::doTastaturEreignis( TastaturEreignis& te )
{
    if( te.verarbeitet || !begonnen )
        return;
    if( end )
    {
        end->doTastaturEreignis( te );
        return;
    }
    if( chat && !chat->istAktiv() )
    {
        if( te.id == TE_Press && !tasten[ te.taste ] )
        {
            char buff[ 2 ] = { 0, (char)te.taste };
            spielKlient->spielNachricht( 2, buff );
            tasten[ te.taste ] = 1;
            te.verarbeitet = 1;
        }
        else if( te.id == TE_Release && tasten[ te.taste ] )
        {
            char buff[ 2 ] = { 1, (char)te.taste };
            spielKlient->spielNachricht( 2, buff );
            tasten[ te.taste ] = 0;
            te.verarbeitet = 1;
        }
    }
    if( chat && !te.verarbeitet )
        chat->doTastaturEreignis( te, spielKlient );
}

void Spiel::stknVerarbeitung()
{
    lock();
    while( stkn->getEintragAnzahl() )
    {
        STKNachricht* n = stkn->z( 0 );
        char* msg = n->getNachricht();
        switch( *msg )
        {
        case 1: // initialisation
        {
            spielerAnzahl = (int)*(msg + 1);
            for( int i = 0; i < spielerAnzahl; i++ )
            {
                int sId = *(int*)(msg + 2 + (__int64)i * 8);
                int aId = *(int*)(msg + 6 + (__int64)i * 8);
                for( auto s : spieler )
                {
                    if( s->getId() == sId )
                    {
                        s->setAccount( aId );
                        if( aId != 0 )
                        {
                            Text* t = infoKlient->getSpielerName( aId );
                            s->setName( t->getText() );
                            t->release();
                        }
                        break;
                    }
                }
            }
            __int64 seed = *(__int64*)(msg + 2 + (__int64)spielerAnzahl * 8);
            randG.setSeed( seed );
            n->setVerarbeitet();
            break;
        }
        case 2: // spielernummer
            spielerNummer = *(int*)(msg + 1);
            for( auto s : spieler )
            {
                if( s->getId() == spielerNummer )
                    spielerGUI->setSpieler( dynamic_cast<Spieler*>(s->getThis()) );
            }
            n->setVerarbeitet();
            break;
        case 3: // spiel start
            throwEvent( new Ereignis( INITIALISIERUNG ) );
            pause = 0;
            begonnen = 1;
            n->setVerarbeitet();
            break;
        case 4: // tasten stand
        {
            char taste = *(char*)(msg + 1);
            char aktiv = *(char*)(msg + 2);
            int sId = *(int*)(msg + 3);
            for( auto s : spieler )
            {
                if( s->getId() == sId )
                {
                    if( s->setTastenStand( taste, aktiv ) )
                    {
                        Ereignis* e = new Ereignis( aktiv ? SPIELER_KEY_PRESSED : SPIELER_KEY_RELEASED );
                        e->addParameter( "Betroffene Taste", new Integer( taste, 1 ) );
                        e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler*>(s->getThis()) );
                        throwEvent( e );
                    }
                    break;
                }
            }
            n->setVerarbeitet();
            break;
        }
        case 5: // Spiel ende
            n->setVerarbeitet();
            break;
        case 6: //tick
            if( rZeit > 0.2 )
            {
                tick();
                n->setVerarbeitet();
            }
            break;
        case 7: // chat nachricht
        {
            char* buf = new char[ (__int64)n->getLength() ];
            memcpy( buf, msg + 1, n->getLength() - 1 );
            buf[ n->getLength() - 1 ] = 0;
            if( chat )
                chat->addNachricht( buf );
            delete[] buf;
            n->setVerarbeitet();
            break;
        }
        }
        if( n->istVerarbeitet() )
            stkn->remove( 0 );
        else
            break;
    }
    unlock();
}

bool Spiel::tick( double zeit )
{
    if( !pause && !end )
        rZeit += zeit;
    stknVerarbeitung();
    int deadsCount = deads->getEintragAnzahl();
    for( int i = 0; i < deadsCount; i++ )
    {
        if( deads->z( i )->isFinished() )
        {
            deads->remove( i-- );
            deadsCount--;
        }
    }
    if( chat )
        chat->tick( zeit );
    return 1;
}

void Spiel::render( Bild& zRObj )
{
    if( spielerGUI )
        spielerGUI->render( zRObj );
    Spieler* i = 0;
    for( auto s : spieler )
    {
        if( s->getId() == spielerNummer )
            i = s;
    }
    if( zRObj.setDrawOptions( 300, 0, zRObj.getBreite() - 300, zRObj.getHeight() ) )
    {
        if( !begonnen )
            zRObj.addScrollOffset( mapSize.x - (zRObj.getBreite() - 300) / 2, mapSize.y - zRObj.getHeight() / 2 );
        else if( i )
            zRObj.addScrollOffset( (int)i->getX() - (zRObj.getBreite() - 300) / 2, (int)i->getY() - zRObj.getHeight() / 2 );
        for( auto f : feuer )
            f->render( zRObj );
        for( auto s : schalter )
            s->render( zRObj );
        for( auto t : tunnel )
            t->render( zRObj );
        for( auto b : basen )
            b->render( zRObj );
        for( auto u : umlenkungen )
            u->render( zRObj );
        for( auto s : schienen )
            s->render( zRObj );
        for( auto i : items )
            i->render( zRObj );
        for( auto b : barieren )
            b->render( zRObj );
        for( auto s : spieler )
        {
            if( s->istSichtbar( zEigenesTeam() ) )
                s->render( zRObj );
        }
        for( auto s : shots )
            s->render( zRObj );
        for( auto a : animations )
            a->render( zRObj );
        for( auto t : timer )
            t->render( zRObj );
        zRObj.releaseDrawOptions();
    }
    int y = 5;
    for( auto b : bestenlisten )
    {
        int x = zRObj.getBreite() - b->getBreite() - 5;
        b->render( x, y, zRObj );
        y += b->getHeight() + 5;
    }
    if( begonnen )
    {
        if( chat )
            chat->render( zRObj );
        if( end )
            end->render( zRObj );
    }
}

void Spiel::setMapSize( int width, int height )
{
    mapSize = Punkt( width, height );
}

void Spiel::setPausiert( bool pausiert )
{
    this->pause = pausiert;
}

void Spiel::addVariable( const char* name, Variable* var )
{
    bool found = 0;
    for( auto v : variablen )
    {
        if( v->getName().istGleich( name ) )
        {
            found = 1;
            break;
        }
    }
    if( !found )
        variablen.add( new VarPointer( name, var ) );
    else
        var->release();
}

void Spiel::setVariable( const char* name, Variable* var )
{
    bool found = 0;
    for( auto v : variablen )
    {
        if( v->getName().istGleich( name ) )
        {
            v->setVariable( var );
            found = 1;
            break;
        }
    }
    if( !found )
        var->release();
}

void Spiel::addTeam( Team* team )
{
    teams.add( team );
}

void Spiel::addSpieler( Spieler* spieler )
{
    this->spieler.add( spieler );
}

void Spiel::addBariere( Bariere* bariere )
{
    nextId = nextId > bariere->getId() ? nextId : bariere->getId() + 1;
    barieren.add( bariere );
}

void Spiel::addBase( Base* base )
{
    nextId = nextId > base->getId() ? nextId : base->getId() + 1;
    basen.add( base );
}

void Spiel::addDrop( Drop* drop )
{
    nextId = nextId > drop->getId() ? nextId : drop->getId() + 1;
    drops.add( drop );
}

void Spiel::addGegenstand( Gegenstand* gegenstand )
{
    nextId = nextId > gegenstand->getId() ? nextId : gegenstand->getId() + 1;
    items.add( gegenstand );
    zuletztGedropterGegenstand = gegenstand->getTyp();
    Ereignis* e = new Ereignis( GEGENSTAND_DROPED );
    e->addParameter( "Betroffener Gegenstand", dynamic_cast<Gegenstand*>(gegenstand->getThis()) );
    throwEvent( e );
}

void Spiel::addGeschoss( Geschoss* geschoss )
{
    nextId = nextId > geschoss->getId() ? nextId : geschoss->getId() + 1;
    if( zuletztAbgefeuertesGeschoss )
        zuletztAbgefeuertesGeschoss->release();
    zuletztAbgefeuertesGeschoss = dynamic_cast<Geschoss*>(geschoss->getThis());
    shots.add( geschoss );
}

void Spiel::addSchalter( Schalter* schalter )
{
    nextId = nextId > schalter->getId() ? nextId : schalter->getId() + 1;
    this->schalter.add( schalter );
}

void Spiel::addSchiene( Schiene* schiene )
{
    nextId = nextId > schiene->getId() ? nextId : schiene->getId() + 1;
    schienen.add( schiene );
}

void Spiel::addTimer( Timer* timer )
{
    nextId = nextId > timer->getId() ? nextId : timer->getId() + 1;
    this->timer.add( timer );
}

void Spiel::addTunnel( Tunnel* tunnel )
{
    nextId = nextId > tunnel->getId() ? nextId : tunnel->getId() + 1;
    this->tunnel.add( tunnel );
}

void Spiel::addUmlenkung( Umlenkung* umlenkung )
{
    nextId = nextId > umlenkung->getId() ? nextId : umlenkung->getId() + 1;
    umlenkungen.add( umlenkung );
}

void Spiel::addTrigger( Trigger* trigger )
{
    nextId = nextId > trigger->getId() ? nextId : trigger->getId() + 1;
    this->trigger.add( trigger );
}

void Spiel::addTriggerRun( TriggerRun* tRun )
{
    if( tRun )
    {
        if( lastRunnedTrigger )
            lastRunnedTrigger->release();
        lastRunnedTrigger = tRun->getTrigger();
        triggerRuns.add( tRun );
    }
}

void Spiel::spielerActivate( Spieler* zSpieler )
{
    // spieler - item intersection
    for( int i = 0; i < items.getEintragAnzahl(); i++ )
    {
        if( items.z( i )->intersectsWith( zSpieler ) )
        {
            if( zSpieler->addItem( items.z( i )->getTyp(), 1, this ) )
            {
                items.remove( i );
                i--;
            }
        }
    }
    // Spieler - schalter intersection
    for( int i = 0; i < schalter.getEintragAnzahl(); i++ )
    {
        if( schalter.z( i )->intersectsWith( zSpieler ) )
        {
            zSpieler->addSchalterBenutzung( this );
            schalter.z( i )->press( this );
        }
    }
    // Spieler - tunnel intersection
    for( int i = 0; i < tunnel.getEintragAnzahl(); i++ )
    {
        if( tunnel.z( i )->intersectsWith( zSpieler ) )
        {
            zSpieler->addTunnelBenutzung( this );
            zSpieler->setX( (float)tunnel.z( i )->getZielX() - zSpieler->getWidth() / 2.f );
            zSpieler->setY( (float)tunnel.z( i )->getZielY() - zSpieler->getHeight() / 2.f );
            tunnel.z( i )->addBenutzung( this );
        }
    }
}

Team* Spiel::getTeam( int id ) const
{
    for( auto t : teams )
    {
        if( t->getTeamNummer() == id )
            return dynamic_cast<Team*>(t->getThis());
    }
    return 0;
}

Spieler* Spiel::getSpieler( int id ) const
{
    for( auto s : spieler )
    {
        if( s->getId() == id )
            return dynamic_cast<Spieler*>(s->getThis());
    }
    return 0;
}

Iterator<Spieler*> Spiel::getSpieler() const
{
    return spieler.begin();
}

Iterator<Bariere*> Spiel::getBarieren() const
{
    return barieren.begin();
}

Bariere* Spiel::getBariere( int id ) const
{
    for( auto b : barieren )
    {
        if( b->getId() == id )
            return dynamic_cast<Bariere*>(b->getThis());
    }
    return 0;
}

Base* Spiel::getBase( int id ) const
{
    for( auto b : basen )
    {
        if( b->getId() == id )
            return dynamic_cast<Base*>(b->getThis());
    }
    return 0;
}

Drop* Spiel::getDrop( int id ) const
{
    for( auto d : drops )
    {
        if( d->getId() == id )
            return dynamic_cast<Drop*>(d->getThis());
    }
    return 0;
}

Schalter* Spiel::getSchalter( int id ) const
{
    for( auto s : schalter )
    {
        if( s->getId() == id )
            return dynamic_cast<Schalter*>(s->getThis());
    }
    return 0;
}

Schiene* Spiel::getSchiene( int id ) const
{
    for( auto s : schienen )
    {
        if( s->getId() == id )
            return dynamic_cast<Schiene*>(s->getThis());
    }
    return 0;
}

Timer* Spiel::getTimer( int id ) const
{
    for( auto t : timer )
    {
        if( t->getId() == id )
            return dynamic_cast<Timer*>(t->getThis());
    }
    return 0;
}

Tunnel* Spiel::getTunnel( int id ) const
{
    for( auto t : tunnel )
    {
        if( t->getId() == id )
            return dynamic_cast<Tunnel*>(t->getThis());
    }
    return 0;
}

Umlenkung* Spiel::getUmlenkung( int id ) const
{
    for( auto u : umlenkungen )
    {
        if( u->getId() == id )
            return dynamic_cast<Umlenkung*>(u->getThis());
    }
    return 0;
}

Trigger* Spiel::getTrigger( int id ) const
{
    for( auto t : trigger )
    {
        if( t->getId() == id )
            return dynamic_cast<Trigger*>(t->getThis());
    }
    return 0;
}

Variable* Spiel::getVariable( const char* name ) const
{
    for( auto v : variablen )
    {
        if( v->getName().istGleich( name ) )
            return v->getVariable();
    }
    return 0;
}

Variable* Spiel::zVariable( const char* name ) const
{
    for( auto v : variablen )
    {
        if( v->getName().istGleich( name ) )
            return v->zVariable();
    }
    return 0;
}

bool Spiel::istPausiert() const
{
    return pause;
}

void Spiel::activateShalter( int id )
{
    for( auto s : schalter )
    {
        if( s->getId() == id )
            s->press( this );
    }
}

void Spiel::throwEvent( Ereignis* e )
{
    for( auto t : trigger )
    {
        if( t->hatEreignis( e->getTyp() ) )
        {
            TriggerRun* tr = t->runTrigger( dynamic_cast<Ereignis*>(e->getThis()), this );
            if( tr )
                triggerRuns.add( tr );
        }
    }
    e->release();
}

bool Spiel::needEvent( EreignisTyp typ ) const
{
    for( auto t : trigger )
    {
        if( t->hatEreignis( typ ) )
            return 1;
    }
    return 0;
}

int Spiel::getNextId()
{
    return ++nextId;
}

double Spiel::getRand()
{
    return randG.rand();
}

int Spiel::getTickCount() const
{
    return gameTicks;
}

void Spiel::setEnde( Team* zGewinner )
{
    zWinner = zGewinner;
    Spieler* i = 0;
    for( auto s : spieler )
    {
        if( s->getId() == spielerNummer )
            i = s;
    }
    end = new Ende( uiFactory );
    end->setGewonnen( (zGewinner && i) ? (i->zTeam() == zGewinner) : -1 );
}

Trigger* Spiel::getRandomTrigger()
{
    if( !trigger.getEintragAnzahl() )
        return 0;
    return trigger.get( (int)(randG.rand() * trigger.getEintragAnzahl()) );
}

Trigger* Spiel::getLastRunnedTrigger() const
{
    return lastRunnedTrigger ? dynamic_cast<Trigger*>(lastRunnedTrigger->getThis()) : 0;
}

Bariere* Spiel::getRandomBariere()
{
    return barieren.get( (int)(randG.rand() * barieren.getEintragAnzahl()) );
}

void Spiel::setZuletztEingeschalteteBariere( Bariere* b )
{
    if( zuletztEingeschalteteBariere )
        zuletztEingeschalteteBariere->release();
    zuletztEingeschalteteBariere = b;
}

Bariere* Spiel::getZuletztEingeschalteteBariere() const
{
    return zuletztEingeschalteteBariere ? dynamic_cast<Bariere*>(zuletztEingeschalteteBariere->getThis()) : 0;
}

void Spiel::setZuletztAusgeschalteteBariere( Bariere* b )
{
    if( zuletztAusgeschalteteBariere )
        zuletztAusgeschalteteBariere->release();
    zuletztAusgeschalteteBariere = b;
}

Bariere* Spiel::getZuletztAusgeschalteteBariere() const
{
    return zuletztAusgeschalteteBariere ? dynamic_cast<Bariere*>(zuletztAusgeschalteteBariere->getThis()) : 0;
}

void Spiel::setZuletztBewegteBariere( Bariere* b )
{
    if( zuletztBewegteBariere )
        zuletztBewegteBariere->release();
    zuletztBewegteBariere = b;
}

Bariere* Spiel::getZuletztBewegteBariere() const
{
    return zuletztBewegteBariere ? dynamic_cast<Bariere*>(zuletztBewegteBariere->getThis()) : 0;
}

Base* Spiel::getRandomBase()
{
    if( !basen.getEintragAnzahl() )
        return 0;
    return basen.get( (int)(randG.rand() * basen.getEintragAnzahl()) );
}

void Spiel::setLastTeamChangedBase( Base* b )
{
    if( lastTeamChangedBase )
        lastTeamChangedBase->release();
    lastTeamChangedBase = b;
}

Base* Spiel::getLastTeamChangedBase() const
{
    return lastTeamChangedBase ? dynamic_cast<Base*>(lastTeamChangedBase->getThis()) : 0;
}

Drop* Spiel::getRandomDrop()
{
    if( !drops.getEintragAnzahl() )
        return 0;
    return drops.get( (int)(randG.rand() * drops.getEintragAnzahl()) );
}

void Spiel::setLastDrop( Drop* d )
{
    if( lastDropedDrop )
        lastDropedDrop->release();
    lastDropedDrop = d;
}

Drop* Spiel::getLastDrop() const
{
    return lastDropedDrop ? dynamic_cast<Drop*>(lastDropedDrop->getThis()) : 0;
}

void Spiel::setItemZuletztAufgehoben( GegenstandTyp g )
{
    zuletztAufgehobenerGegenstand = g;
}

GegenstandTyp Spiel::getItemZuletztAufgehoben() const
{
    return zuletztAufgehobenerGegenstand;
}

void Spiel::setItemZuletztAktiviert( GegenstandTyp g )
{
    zuletztBenutzterGegenstand = g;
}

GegenstandTyp Spiel::getItemZuletztAktiviert() const
{
    return zuletztBenutzterGegenstand;
}

GegenstandTyp Spiel::getItemZuletztGedropt() const
{
    return zuletztGedropterGegenstand;
}

Geschoss* Spiel::getRandomGeschoss()
{
    if( !shots.getEintragAnzahl() )
        return 0;
    return shots.get( (int)(randG.rand() * shots.getEintragAnzahl()) );
}

Geschoss* Spiel::getGeschossZuletztAbgefeuert() const
{
    return zuletztAbgefeuertesGeschoss ? dynamic_cast<Geschoss*>(zuletztAbgefeuertesGeschoss->getThis()) : 0;
}

void Spiel::setGeschossZuletztUmgelenkt( Geschoss* g )
{
    if( zuletztUmgelenktesGeschoss )
        zuletztUmgelenktesGeschoss->release();
    zuletztUmgelenktesGeschoss = g;
}

Geschoss* Spiel::getGeschossZuletztUmgelenkt() const
{
    return zuletztUmgelenktesGeschoss ? dynamic_cast<Geschoss*>(zuletztUmgelenktesGeschoss->getThis()) : 0;
}

Geschoss* Spiel::getGeschossZuletztBariereGetroffen() const
{
    return zuletztBariereGetroffenesGeschoss ? dynamic_cast<Geschoss*>(zuletztBariereGetroffenesGeschoss->getThis()) : 0;
}

void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss* g )
{
    if( zuletztTunnelBenutztesGeschoss )
        zuletztTunnelBenutztesGeschoss->release();
    zuletztTunnelBenutztesGeschoss = g;
}

Geschoss* Spiel::getGeschossZuletztTunnelBenutzt() const
{
    return zuletztTunnelBenutztesGeschoss ? dynamic_cast<Geschoss*>(zuletztTunnelBenutztesGeschoss->getThis()) : 0;
}

void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss* g )
{
    if( zuletztGeschossGetroffenesGeschoss )
        zuletztGeschossGetroffenesGeschoss->release();
    zuletztGeschossGetroffenesGeschoss = g;
}

Geschoss* Spiel::getGeschossZuletztGeschossGetroffen() const
{
    return zuletztGeschossGetroffenesGeschoss ? dynamic_cast<Geschoss*>(zuletztGeschossGetroffenesGeschoss->getThis()) : 0;
}

Schalter* Spiel::getRandomSchalter()
{
    if( !schalter.getEintragAnzahl() )
        return 0;
    return schalter.get( (int)(randG.rand() * schalter.getEintragAnzahl()) );
}

void Spiel::setSchalterZuletztAktiviert( Schalter* s )
{
    if( zuletztAktivierterSchalter )
        zuletztAktivierterSchalter->release();
    zuletztAktivierterSchalter = s;
}

Schalter* Spiel::getSchalterZuletztAktiviert() const
{
    return zuletztAktivierterSchalter ? dynamic_cast<Schalter*>(zuletztAktivierterSchalter->getThis()) : 0;
}

Spieler* Spiel::getRandomSpieler()
{
    if( !spieler.getEintragAnzahl() )
        return 0;
    return spieler.get( (int)(randG.rand() * spieler.getEintragAnzahl()) );
}

Spieler* Spiel::getRandomSpieler( Team* zTeam )
{
    if( !zTeam || !zTeam->getSpielerAnzahl() )
        return 0;
    int index = (int)(randG.rand() * zTeam->getSpielerAnzahl());
    for( auto s : spieler )
    {
        if( s->zTeam() == zTeam )
        {
            if( index-- <= 0 )
                return dynamic_cast<Spieler*>(s->getThis());
        }
    }
    return 0;
}

void Spiel::setSpielerZuletztSchadenGemacht( Spieler* s )
{
    if( zuletztSchadenGemachterSpieler )
        zuletztSchadenGemachterSpieler->release();
    zuletztSchadenGemachterSpieler = s;
}

Spieler* Spiel::getSpielerZuletztSchadenGemacht() const
{
    return zuletztSchadenGemachterSpieler ? dynamic_cast<Spieler*>(zuletztSchadenGemachterSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztSchadenGenommen( Spieler* s )
{
    if( zuletztSchadenGenommenerSpieler )
        zuletztSchadenGenommenerSpieler->release();
    zuletztSchadenGenommenerSpieler = s;
}

Spieler* Spiel::getSpielerZuletztSchadenGenommen() const
{
    return zuletztSchadenGenommenerSpieler ? dynamic_cast<Spieler*>(zuletztSchadenGenommenerSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztGeheilt( Spieler* s )
{
    if( zuletztGeheilterSpieler )
        zuletztGeheilterSpieler->release();
    zuletztGeheilterSpieler = s;
}

Spieler* Spiel::getSpielerZuletztGeheilt() const
{
    return zuletztGeheilterSpieler ? dynamic_cast<Spieler*>(zuletztGeheilterSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztLevelUp( Spieler* s )
{
    if( zuletztLevelUpSpieler )
        zuletztLevelUpSpieler->release();
    zuletztLevelUpSpieler = s;
}

Spieler* Spiel::getSpielerZuletztLevelUp() const
{
    return zuletztLevelUpSpieler ? dynamic_cast<Spieler*>(zuletztLevelUpSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztErfahrungBekommen( Spieler* s )
{
    if( zuletztErfahrungBekommenerSpieler )
        zuletztErfahrungBekommenerSpieler->release();
    zuletztErfahrungBekommenerSpieler = s;
}

Spieler* Spiel::getSpielerZuletztErfahrungBekommen() const
{
    return zuletztErfahrungBekommenerSpieler ? dynamic_cast<Spieler*>(zuletztErfahrungBekommenerSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler* s )
{
    if( zuletztGegenstandAktivierterSpieler )
        zuletztGegenstandAktivierterSpieler->release();
    zuletztGegenstandAktivierterSpieler = s;
}

Spieler* Spiel::getSpielerZuletztGegenstandAktiviert() const
{
    return zuletztGegenstandAktivierterSpieler ? dynamic_cast<Spieler*>(zuletztGegenstandAktivierterSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler* s )
{
    if( zuletztGegenstandAufgehobenerSpieler )
        zuletztGegenstandAufgehobenerSpieler->release();
    zuletztGegenstandAufgehobenerSpieler = s;
}

Spieler* Spiel::getSpielerZuletztGegenstandAufgehoben() const
{
    return zuletztGegenstandAufgehobenerSpieler ? dynamic_cast<Spieler*>(zuletztGegenstandAufgehobenerSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztSchalterAktiviert( Spieler* s )
{
    if( zuletztSchalterAktivierterSpieler )
        zuletztSchalterAktivierterSpieler->release();
    zuletztSchalterAktivierterSpieler = s;
}

Spieler* Spiel::getSpielerZuletztSchalterAktiviert() const
{
    return zuletztSchalterAktivierterSpieler ? dynamic_cast<Spieler*>(zuletztSchalterAktivierterSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztTunnelBenutzt( Spieler* s )
{
    if( zuletztTunnelBenutzterSpieler )
        zuletztTunnelBenutzterSpieler->release();
    zuletztTunnelBenutzterSpieler = s;
}

Spieler* Spiel::getSpielerZuletztTunnelBenutzt() const
{
    return zuletztTunnelBenutzterSpieler ? dynamic_cast<Spieler*>(zuletztTunnelBenutzterSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztGestorben( Spieler* s )
{
    if( zuletztGestorbenerSpieler )
        zuletztGestorbenerSpieler->release();
    zuletztGestorbenerSpieler = s;
}

Spieler* Spiel::getSpielerZuletztGestorben() const
{
    return zuletztGestorbenerSpieler ? dynamic_cast<Spieler*>(zuletztGestorbenerSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztWiederbelebt( Spieler* s )
{
    if( zuletztWiederbelebterSpieler )
        zuletztWiederbelebterSpieler->release();
    zuletztWiederbelebterSpieler = s;
}

Spieler* Spiel::getSpielerZuletztWiederbelebt() const
{
    return zuletztWiederbelebterSpieler ? dynamic_cast<Spieler*>(zuletztWiederbelebterSpieler->getThis()) : 0;
}

void Spiel::setSpielerZuletztGeschossen( Spieler* s )
{
    if( zuletztGeschossenerSpieler )
        zuletztGeschossenerSpieler->release();
    zuletztGeschossenerSpieler = s;
}

Spieler* Spiel::getSpielerZuletztGeschossen() const
{
    return zuletztGeschossenerSpieler ? dynamic_cast<Spieler*>(zuletztGeschossenerSpieler->getThis()) : 0;
}

Team* Spiel::getRandomTeam()
{
    if( !teams.getEintragAnzahl() )
        return 0;
    return teams.get( (int)(randG.rand() * teams.getEintragAnzahl()) );
}

Timer* Spiel::getRandomTimer()
{
    if( !timer.getEintragAnzahl() )
        return 0;
    return timer.get( (int)(randG.rand() * timer.getEintragAnzahl()) );
}

void Spiel::setTimerZuletztAbgelaufen( Timer* t )
{
    if( zuletztAbgelaufenerTimer )
        zuletztAbgelaufenerTimer->release();
    zuletztAbgelaufenerTimer = t;
}

Timer* Spiel::getTimerZuletztAbgelaufen() const
{
    return zuletztAbgelaufenerTimer ? dynamic_cast<Timer*>(zuletztAbgelaufenerTimer->getThis()) : 0;
}

void Spiel::setTimerZuletztGestartet( Timer* t )
{
    if( zuletztGestarteterTimer )
        zuletztGestarteterTimer->release();
    zuletztGestarteterTimer = t;
}

Timer* Spiel::getTimerZuletztGestartet() const
{
    return zuletztGestarteterTimer ? dynamic_cast<Timer*>(zuletztGestarteterTimer->getThis()) : 0;
}

void Spiel::setTimerZuletztPausiert( Timer* t )
{
    if( zuletztPausierterTimer )
        zuletztPausierterTimer->release();
    zuletztPausierterTimer = t;
}

Timer* Spiel::getTimerZuletztPausiert() const
{
    return zuletztPausierterTimer ? dynamic_cast<Timer*>(zuletztPausierterTimer->getThis()) : 0;
}

void Spiel::setTimerZuletztFortgesetzt( Timer* t )
{
    if( zuletztFortgesetzterTimer )
        zuletztFortgesetzterTimer->release();
    zuletztFortgesetzterTimer = t;
}

Timer* Spiel::getTimerZuletztFortgesetzt() const
{
    return zuletztFortgesetzterTimer ? dynamic_cast<Timer*>(zuletztFortgesetzterTimer->getThis()) : 0;
}

Tunnel* Spiel::getRandomTunnel()
{
    if( !tunnel.getEintragAnzahl() )
        return 0;
    return tunnel.get( (int)(randG.rand() * tunnel.getEintragAnzahl()) );
}

void Spiel::setTunnelZuletztBenutzt( Tunnel* t )
{
    if( zuletztBenutzterTunnel )
        zuletztBenutzterTunnel->release();
    zuletztBenutzterTunnel = t;
}

Tunnel* Spiel::getTunnelZuletztBenutzt() const
{
    return zuletztBenutzterTunnel ? dynamic_cast<Tunnel*>(zuletztBenutzterTunnel->getThis()) : 0;
}

Umlenkung* Spiel::getRandomUmlenkung()
{
    if( !umlenkungen.getEintragAnzahl() )
        return 0;
    return umlenkungen.get( (int)(randG.rand() * umlenkungen.getEintragAnzahl()) );
}

void Spiel::setUmlenkungZuletztBenutzt( Umlenkung* t )
{
    if( zuletztBenutzteUmlenkung )
        zuletztBenutzteUmlenkung->release();
    zuletztBenutzteUmlenkung = t;
}

Umlenkung* Spiel::getUmlenkungZuletztBenutzt() const
{
    return zuletztBenutzteUmlenkung ? dynamic_cast<Umlenkung*>(zuletztBenutzteUmlenkung->getThis()) : 0;
}

ResourceRegistry* Spiel::zResources() const
{
    return resources;
}

void Spiel::addAnimation( SingleAnimation* animation )
{
    animations.add( animation );
}

void Spiel::addBestenliste( Bestenliste* b )
{
    bestenlisten.add( b );
}

int Spiel::läuft() const
{
    if( !begonnen )
        return 3;
    if( !end )
        return 2;
    if( end && !end->getWeiter() )
        return 1;
    if( end && end->getWeiter() )
        return 0;
    return 0;
}