Kommunikation mit server fertig

StickmanWorldOnline/Spiel.cpp

@@ -1,10 +1,32 @@
 #include "Spiel.h"
 
+#define TICK 0.03333333
 
 // Konstruktor
 Spiel::Spiel()
 {
-
+    stkn = new RCArray< STKNachricht >();
+    schrift = 0;
+    infoKlient = 0;
+    spielKlient = 0;
+    zScreen = 0;
+    chat = new SpielChat();
+    end = 0;
+    spielerGUI = new SpielerGUI();
+    deads = new RCArray< DeadPlayer >();
+    nextId = 0;
+    rendern = 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;
@@ -44,6 +66,18 @@ Spiel::Spiel()
 // Destruktor
 Spiel::~Spiel()
 {
+    stkn->release();
+    if( schrift )
+        schrift->release();
+    if( infoKlient )
+        infoKlient->release();
+    if( spielKlient )
+        spielKlient->release();
+    chat->relese();
+    if( end )
+        end->release();
+    spielerGUI->release();
+    deads->release();
     if( lastRunnedTrigger )
         lastRunnedTrigger->release();
     if( zuletztEingeschalteteBariere )
@@ -104,67 +138,472 @@ Spiel::~Spiel()
         zuletztBenutzterTunnel->release();
     if( zuletztBenutzteUmlenkung )
         zuletztBenutzteUmlenkung->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()
+{
+    rZeit -= TICK;// spieler bewegungen
+    for( auto s = spieler.getIterator(); s; s++ )
+    {
+        s->move( TICK );
+        if( s->getX() < 0 || s->getY() < 0 || s->getX() + s->getWidth() >= mapSize.x || s->getY() + s->getHeight() >= mapSize.y )
+            s->move( -TICK );
+        else
+        {
+            for( auto b = barieren.getIterator(); b; b++ )
+            { // spieler - bariere intersection
+                if( b->hatStyle( Bariere::Style::Aktiv ) && ( b->zTeam() != s->zTeam() ) && b->intersectsWith( s ) )
+                    s->move( -TICK );
+            }
+        }
+    }
+    for( auto s = spieler.getIterator(); s; s++ )
+        s->tick( TICK, this );
+    // barieren bewegung
+    for( auto b = barieren.getIterator(); b; b++ )
+        b->tick( TICK, this );
+    // geschoss bewegung
+    for( int i = 0; i < shots.getEintragAnzahl(); i++ )
+    {
+        Geschoss *g = shots.z( i );
+        g->tick( TICK );
+        bool removed = 0;
+        // geschoss - bariere intersection
+        bool intersectsWithBariere = 0;
+        for( auto b = barieren.getIterator(); b; b++ )
+        {
+            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 = (Geschoss *)g->getThis();
+            g->tick( -TICK );
+            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( ++nextId, (int)g->getX() - 70, (int)g->getY() - 70, g->getBesitzer(), 10 ) );
+                    shots.remove( i );
+                    i--;
+                    removed = 1;
+                }
+                else
+                    g->invertDirection();
+                break;
+            case GESCHOSS_MINE:
+                for( auto s = spieler.getIterator(); s; s++ )
+                {
+                    if( s->abstandZu( g ) < 50 )
+                    {
+                        s->nimmSchaden( 100 - s->abstandZu( g ), g->zBesitzer(), MITTE, this );
+                        if( g->zBesitzer() )
+                            g->zBesitzer()->addTreffer( this );
+                        s->addGetroffen();
+                    }
+                }
+                shots.remove( i );
+                i--;
+                removed = 1;
+                break;
+            }
+        }
+        if( !removed )
+        { // geschoss - tunnel intersection
+            for( auto t = tunnel.getIterator(); t; t++ )
+            {
+                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", g->getThis() );
+                    e->addParameter( "Betroffer Tunnel", t->getThis() );
+                    throwEvent( e );
+                }
+            }
+            // geschoss - schalter intersection
+            if( g->getTyp() == GESCHOSS_PFEIL )
+            {
+                for( auto s = schalter.getIterator(); s; s++ )
+                {
+                    if( s->isAktive() && s->intersectsWith( g ) )
+                    {
+                        shots.remove( i );
+                        i--;
+                        removed = 1;
+                        g->addSchalter();
+                        activateShalter( s->getId() );
+                    }
+                }
+            }
+            if( !removed )
+            {
+                // geschoss - umlenkung intersection
+                if( g->getTyp() != GESCHOSS_PFEIL )
+                {
+                    for( auto u = umlenkungen.getIterator(); u; u++ )
+                    {
+                        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", g->getThis() );
+                            e->addParameter( "Betroffe 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 ) )
+                        {
+                            if( g2->getTyp() == GESCHOSS_PFEIL )
+                                removed = 1;
+                            g->addGeschossTreffer( this );
+                            if( j < i )
+                                i--;
+                            shots.remove( j );
+                        }
+                    }
+                }
+                if( !removed )
+                {
+                    // geschoss - spieler intersection
+                    for( auto s = spieler.getIterator(); s; s++ )
+                    {
+                        if( s->istAmLeben() && s != g->zBesitzer() && g->intersectsWith( s ) )
+                        {
+                            switch( g->getTyp() )
+                            {
+                            case GESCHOSS_PFEIL:
+                            {
+                                s->nimmSchaden( PFEIL_DAMAGE, g->zBesitzer(), invert( g->getRichtung() ), this );
+                                break;
+                            }
+                            case GESCHOSS_KUGEL:
+                            {
+                                s->nimmSchaden( KUGEL_DAMAGE, g->zBesitzer(), invert( g->getRichtung() ), this );
+                                break;
+                            }
+                            case GESCHOSS_DRACHENAUGE:
+                                s->addEffekt( new DrachenAugeEffect( g->zBesitzer(), s._ ) );
+                                break;
+                            case GESCHOSS_FEUERBALL:
+                                feuer.add( new FeuerballTreffer( ++nextId, (int)g->getX() - 70, (int)g->getY() - 70, g->getBesitzer(), 10 ) );
+                                break;
+                            case GESCHOSS_MINE:
+                                for( auto s2 = spieler.getIterator(); s2; s2++ )
+                                {
+                                    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;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Feuer Ticks
+    for( int i = 0; i < feuer.getEintragAnzahl(); i++ )
+    {
+        FeuerballTreffer *f = feuer.z( i );
+        f->tick( TICK );
+        if( f->isOver() )
+        {
+            feuer.remove( i );
+            i--;
+            continue;
+        }
+        if( f->makeDamage() )
+        {
+            for( auto s = spieler.getIterator(); s; s++ )
+            {
+                if( s->abstandZu( f ) < f->getWidth() / 2 )
+                    s->addEffekt( new BrandEffekt( f->zVerursacher(), s ) );
+            }
+        }
+    }
+    // Drop Ticks
+    for( auto d = drops.getIterator(); d; d++ )
+        d->tick( TICK, this );
+    // Timer Ticks
+    for( auto t = timer.getIterator(); t; t++ )
+        t->tick( TICK, this );
+    // Umlenkung Ticks
+    for( auto u = umlenkungen.getIterator(); u; u++ )
+        u->tick( TICK );
+    // Base Ticks
+    for( auto b = basen.getIterator(); b; b++ )
+        b->tick( TICK, this );
+    // aktive trigger Ticks
+    for( int i = 0; i < triggerRuns.getEintragAnzahl(); i++ )
+    {
+        if( !triggerRuns.z( i )->runNext( TICK ) )
+        {
+            Ereignis *e = new Ereignis( AUSLOESER_RUNNED );
+            e->addParameter( "Betroffener Auslöser", triggerRuns.z( i )->getTrigger() );
+            throwEvent( e );
+            triggerRuns.remove( i );
+            i--;
+        }
+    }
 }
 
 // nicht constant
 void Spiel::lock()
 {
-
+    c.lock();
 }
 
 void Spiel::unlock()
 {
-
+    c.unlock();
 }
 
+// call 4
 void Spiel::setSchrift( Schrift *schrift )
 {
-
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
 }
- // call 4
+
+// call 3
 void Spiel::setBildschirm( Bildschirm *zScreen )
 {
-
+    this->zScreen = zScreen;
 }
- // call 3
+
 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 2
+
+// call 1
 void Spiel::setKarteId( int karteId )
 {
-
+    this->karteId = karteId;
 }
- // call 1
+
+// call 5
 void Spiel::ladeDaten()
 {
+    Text *gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
+    Text *mapPf = new Text( "data/tmp/Karten/" );
+    mapPf->append( karteId );
+    mapPf->append( "/spiel/data/data.sts" );
 
+    spielKlient->setLadenProzent( 100 );
+    mapPf->release();
+    gamePath->release();
 }
- // call 5
+
 void Spiel::doPublicMausEreignis( MausEreignis &me )
 {
-
+    if( me.verarbeitet )
+        return;
+    if( end )
+    {
+        end->doPublicMausEreignis( me );
+        return;
+    }
+    chat->doPublicMausEreignis( me );
 }
 
 void Spiel::doTastaturEreignis( TastaturEreignis &te )
 {
-
+    if( te.verarbeitet )
+        return;
+    if( end )
+    {
+        end->doTastaturEreignis( te );
+        return;
+    }
+    if( !chat->istAktiv() )
+    {
+        if( te.id == TE_Press && !tasten[ te.taste ] )
+        {
+            char buff[ 2 ] = { 0, 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, te.taste };
+            spielKlient->spielNachricht( 2, buff );
+            tasten[ te.taste ] = 0;
+            te.verarbeitet = 1;
+        }
+    }
+    if( !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 + i * 8 );
+                int aId = *(int *)( msg + 6 + i * 8 );
+                for( auto s = spieler.getIterator(); s; s++ )
+                {
+                    if( s->getId() == sId )
+                    {
+                        s->setAccount( aId );
+                        Text *t = infoKlient->getSpielerName( aId );
+                        s->setName( t->getText() );
+                        t->release();
+                        break;
+                    }
+                }
+            }
+            n->setVerarbeitet();
+            break;
+        case 2: // spielernummer
+            spielerNummer = *(int *)( msg + 1 );
+            n->setVerarbeitet();
+            break;
+        case 3: // spiel start
+            pause = 0;
+            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.getIterator(); s; s++ )
+            {
+                if( s->getId() == sId )
+                {
+                    s->setTastenStand( taste, aktiv );
+                    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
+        {
+            unsigned char len = ( unsigned char ) * ( msg + 1 );
+            char *buf = new char[ len + 1 ];
+            memcpy( buf, msg + 2, len );
+            buf[ len ] = 0;
+            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--;
+        }
+    }
+    chat->tick( zeit );
+    return 1;
 }
 
 void Spiel::render( Bild &zRObj )

StickmanWorldOnline/Spiel.h

@@ -18,6 +18,8 @@
 #include "Trigger.h"
 #include "Tunnel.h"
 #include "Umlenkung.h"
+#include "DrachenAuge.h"
+#include "Brand.h"
 
 class SpielerGUI;
 class DeadPlayer;
@@ -26,17 +28,13 @@ class Spiel : public SpielV
 {
 private:
     RCArray< STKNachricht > *stkn;
-    int stkna;
     Schrift *schrift;
     KSGClient::InformationServerClient *infoKlient;
     KSGClient::SpielServerClient *spielKlient;
-    Bildschirm *screen;
-    Kamera2D *kam;
-    Kamera2D *minimap;
-    Welt2D *welt;
+    Bildschirm *zScreen;
     SpielChat *chat;
     Ende *end;
-    SpielerGUI *shipGUI;
+    SpielerGUI *spielerGUI;
     RCArray< DeadPlayer > *deads;
     RandomGenerator randG;
     RCArray< VarPointer > variablen;
@@ -101,14 +99,9 @@ private:
     int spielerNummer;
     char *tasten;
     bool pause;
-    bool setKam;
     int ref;
 
     bool istAmLeben() const;
-    void goBackInTime( int zeit );
-    void goToPresence( int zeit );
-    void load();
-    void save();
     void tick();
 
 public:

StickmanWorldOnline/Spieler.cpp

@@ -725,11 +725,6 @@ float Spieler::getSchadenBonus() const
     return schadensBonus;
 }
 
-int Spieler::getSpielerNummer() const
-{
-    return spielerNummer;
-}
-
 Team *Spieler::zTeam() const
 {
     return team;

StickmanWorldOnline/Spieler.h

@@ -124,7 +124,6 @@ public:
     float getGeschossTempo() const;
     float getLebensRaub() const;
     float getSchadenBonus() const;
-    int getSpielerNummer() const;
     Team *zTeam() const;
     Team *getTeam() const;
     int getFarbe() const;