Statistik hinzugefügt

StickmanWorldOnline/Aktionen.cpp

@@ -807,7 +807,7 @@ TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions )
 
 void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Timer *)zParam( 1 ) )->setPause( ( (Boolean *)zParam( 0 ) )->getValue() );
+    ( (Timer *)zParam( 1 ) )->setPause( zSpiel, ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 

StickmanWorldOnline/SSKlient.h

@@ -5,8 +5,7 @@
 #include "SSKlientV.h"
 
 class Spieler;
-class SpielerStatistik;
-class TeamStatistik;
+class Team;
 
 class Klient
 {
@@ -31,8 +30,8 @@ public:
     void sendeChatNachricht( char *txt, int spielZeit );
     void sendeStatistikChatNachricht( int vonAccount, char *txt );
     void sendeStatistikSpielerOffline( int account );
-    void sendeSpielerStatistik( SpielerStatistik *zS );
-    void sendeTeamStatistik( TeamStatistik *zS );
+    void sendeSpielerStatistik( Spieler *zS );
+    void sendeTeamStatistik( Team *zS );
     void sendeStatistikLadenFertig();
     // constant
     bool istOnline() const;

StickmanWorldOnline/Spiel.cpp

@@ -180,8 +180,8 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
     }
     zAccounts = zAccounts->release();
     zKlients = zKlients->release();
-    stat->setTeams( spielerAnzahl, &teams );
-    stat->setSpieler( spielerAnzahl, &spieler );
+    stat->setTeams( &teams );
+    stat->setSpieler( &spieler );
 }
 // call 6
 void Spiel::run()
@@ -214,7 +214,10 @@ void Spiel::run()
             if( len )
                 log->schreibe( name->getText(), len );
             if( name )
+            {
+                tmp->setName( name->getText() );
                 name->release();
+            }
         }
     }
     __int64 randSeed = randG.getSeed();
@@ -576,7 +579,7 @@ void Spiel::tick( double zeit )
                         {
                             g->setRichtung( u->getRichtung() );
                             g->addUmlenkung( this );
-                            u->addBenutzt();
+                            u->addBenutzt( this );
                             Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
                             e->addParameter( "Betroffes Geschoss", g->getThis() );
                             e->addParameter( "Betroffe Umlenkung", u->getThis() );
@@ -846,7 +849,7 @@ void Spiel::spielerActivate( Spieler *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();
+            tunnel.z( i )->addBenutzung( this );
         }
     }
 }
@@ -1390,7 +1393,7 @@ void Spiel::setSpielerZuletztWiederbelebt( Spieler *s )
 
 Spieler *Spiel::getSpielerZuletztWiederbelebt() const
 {
-    return zuletztWiederbelebterSpieler ? (Spieler*)zuletztWiederbelebterSpieler->getThis() : 0;
+    return zuletztWiederbelebterSpieler ? (Spieler *)zuletztWiederbelebterSpieler->getThis() : 0;
 }
 
 void Spiel::setSpielerZuletztGeschossen( Spieler *s )
@@ -1402,7 +1405,107 @@ void Spiel::setSpielerZuletztGeschossen( Spieler *s )
 
 Spieler *Spiel::getSpielerZuletztGeschossen() const
 {
-    return zuletztGeschossenerSpieler ? (Spieler*)zuletztGeschossenerSpieler->getThis() : 0;
+    return zuletztGeschossenerSpieler ? (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 ? (Timer *)zuletztAbgelaufenerTimer->getThis() : 0;
+}
+
+void Spiel::setTimerZuletztGestartet( Timer *t )
+{
+    if( zuletztGestarteterTimer )
+        zuletztGestarteterTimer->release();
+    zuletztGestarteterTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztGestartet() const
+{
+    return zuletztGestarteterTimer ? (Timer *)zuletztGestarteterTimer->getThis() : 0;
+}
+
+void Spiel::setTimerZuletztPausiert( Timer *t )
+{
+    if( zuletztPausierterTimer )
+        zuletztPausierterTimer->release();
+    zuletztPausierterTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztPausiert() const
+{
+    return zuletztPausierterTimer ? (Timer *)zuletztPausierterTimer->getThis() : 0;
+}
+
+void Spiel::setTimerZuletztFortgesetzt( Timer *t )
+{
+    if( zuletztFortgesetzterTimer )
+        zuletztFortgesetzterTimer->release();
+    zuletztFortgesetzterTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztFortgesetzt() const
+{
+    return zuletztFortgesetzterTimer ? (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 ? (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 ? (Umlenkung*)zuletztBenutzteUmlenkung->getThis() : 0;
 }
 
 StatistikV *Spiel::getStatistik() const

StickmanWorldOnline/SpielerStatistik.h

@@ -1,6 +0,0 @@
-#pragma once
-
-class SpielerStatistik
-{
-
-};

StickmanWorldOnline/Statistik.cpp

@@ -0,0 +1,192 @@
+#include <DateiSystem.h>
+#include <Datei.h>
+#include <InitDatei.h>
+#include "Spieler.h"
+#include "Team.h"
+#include "SSKlient.h"
+#ifndef WIN32
+#define Sleep( x )    usleep( (x) * 1000 )
+#endif
+#include "Statistik.h"
+
+// Inhalt der Statistik Klasse aus Statistik.h
+// Konstruktor
+Statistik::Statistik()
+{
+    spielId = 0;
+    karteId = 0;
+    db = 0;
+    spieler = new RCArray< Spieler >();
+    teams = new RCArray< Team >();
+    erstellt = 0;
+    sOnline = new Array< bool >();
+    sBereit = new Array< bool >();
+    gewinnerTeam = 0;
+    ref = 1;
+}
+
+// Destruktor
+Statistik::~Statistik()
+{
+    if( db )
+        db->release();
+    for( auto s = spieler->getIterator(); s; s++ )
+        s->setTeam( 0 );
+    spieler->release();
+    teams->release();
+    sOnline->release();
+    sBereit->release();
+}
+
+// privat
+void Statistik::sendeStatistik( int index )
+{ // Sendet Statistik an Spieler index
+    if( !sOnline->hat( index ) || !sOnline->get( index ) )
+        return;
+    Klient *zk = spieler->z( index )->zKlient();
+    if( !zk )
+        return;
+    for( auto s = spieler->getIterator(); s; s++ )
+        zk->sendeSpielerStatistik( s );
+    for( auto t = teams->getIterator(); t; t++ )
+        zk->sendeTeamStatistik( t );
+    zk->sendeStatistikLadenFertig();
+    for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+    {
+        if( !sOnline->hat( i ) || !sOnline->get( i ) )
+            zk->sendeStatistikSpielerOffline( spieler->z( i )->getAccountId() );
+    }
+}
+
+// nicht constant
+void Statistik::setSpielId( int id )
+{
+    spielId = id;
+}
+
+void Statistik::setKarteId( int id )
+{
+    karteId = id;
+}
+
+void Statistik::setPSQLDB( SSDatenbankV *db )
+{
+    if( this->db )
+        this->db->release();
+    this->db = db;
+}
+
+void Statistik::spielEnde( int team )
+{
+    gewinnerTeam = team;
+}
+
+void Statistik::setTeams( RCArray< Team > *zTeams )
+{
+    for( int i = 0; i < zTeams->getEintragAnzahl(); i++ )
+        teams->set( zTeams->get( i ), i );
+}
+
+void Statistik::setSpieler( RCArray< Spieler > *zSpieler )
+{
+    for( int i = 0; i < zSpieler->getEintragAnzahl(); i++ )
+    {
+        spieler->set( zSpieler->get( i ), i );
+        sOnline->set( 0, i );
+        sBereit->set( 0, i );
+    }
+}
+
+void Statistik::klientOffline( int accountId )
+{
+    for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+    {
+        if( spieler->z( i )->getAccountId() == accountId )
+        {
+            sOnline->set( 0, i );
+            sBereit->set( 0, i );
+        }
+        else if( sOnline->hat( i ) && sOnline->get( i ) && spieler->z( i )->zKlient() )
+            spieler->z( i )->zKlient()->sendeStatistikSpielerOffline( accountId );
+    }
+}
+
+void Statistik::statistikAnfrage( int accountId, short len, char *bytes )
+{
+    len--;
+    switch( *bytes )
+    {
+    case 0: // Spieler ist Bereit
+        for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+        {
+            if( !erstellt )
+            {
+                if( spieler->z( i )->getAccountId() == accountId )
+                    sBereit->set( 1, i );
+            }
+            else if( spieler->z( i )->getAccountId() == accountId )
+            {
+                sendeStatistik( i );
+                break;
+            }
+        }
+        break;
+    case 1: // Chat Nachricht
+        bytes++;
+        char *txt = new char[ len + 1 ];
+        txt[ len ] = 0;
+        for( int i = 0; i < len; i++ )
+            txt[ i ] = bytes[ i ];
+        for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+        {
+            if( sOnline->hat( i ) && sOnline->get( i ) && spieler->z( i )->zKlient() )
+                spieler->z( i )->zKlient()->sendeStatistikChatNachricht( accountId, txt );
+        }
+        delete[] txt;
+        break;
+    }
+}
+
+void Statistik::run()
+{
+    for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+        sOnline->set( spieler->z( i )->zKlient() && spieler->z( i )->zKlient()->istOnline(), i );
+    // Statistik erstellen
+    erstellt = 1;
+    // Statistik senden
+    for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+    {
+        if( sBereit->hat( i ) && sBereit->get( i ) )
+            sendeStatistik( i );
+    }
+    // Statistik speichern
+    Text *pfad = new Text( "../spiel log/" );
+    pfad->append( spielId );
+    pfad->append( "/fertig" );
+    DateiPfadErstellen( pfad );
+    // warten bis alle verlassen haben
+    while( 1 )
+    {
+        Sleep( 1000 );
+        int online = 0;
+        for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
+            online += sOnline->hat( i ) && sOnline->get( i );
+        if( !online )
+            break;
+    }
+}
+
+// Reference Counting
+StatistikV *Statistik::getThis()
+{
+    ref++;
+    return this;
+}
+
+StatistikV *Statistik::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Statistik.h

@@ -3,8 +3,7 @@
 #include "StatistikKlasse.h"
 #include "SSDatenbankV.h"
 #include "Spieler.h"
-#include "SpielerStatistik.h"
-#include "TeamStatistik.h"
+#include "Team.h"
 
 class Statistik : public StatistikV
 {
@@ -12,14 +11,11 @@ private:
     int spielId;
     int karteId;
     SSDatenbankV *db;
-    int spielerAnzahl;
     RCArray< Spieler > *spieler;
+    RCArray< Team > *teams;
     bool erstellt;
     Array< bool > *sOnline;
     Array< bool > *sBereit;
-    RCArray< SpielerStatistik > *gss;
-    RCArray< TeamStatistik > *gts;
-    RCArray< Text > *teamNamen;
     int gewinnerTeam;
     int ref;
 
@@ -35,8 +31,8 @@ public:
     void setKarteId( int id );
     void setPSQLDB( SSDatenbankV *db );
     void spielEnde( int team );
-    void setTeams( int anzahl, RCArray< Team > *zTeams );
-    void setSpieler( int anzahl, RCArray< Spieler > *zSpieler );
+    void setTeams( RCArray< Team > *zTeams );
+    void setSpieler( RCArray< Spieler > *zSpieler );
     virtual void klientOffline( int accountId );
     virtual void statistikAnfrage( int accountId, short len, char *bytes );
     virtual void run();

StickmanWorldOnline/StickmanWorldOnline.vcxproj

@@ -102,6 +102,7 @@
     <ClCompile Include="Schuh.cpp" />
     <ClCompile Include="Spiel.cpp" />
     <ClCompile Include="Spieler.cpp" />
+    <ClCompile Include="Statistik.cpp" />
     <ClCompile Include="StrengthRune.cpp" />
     <ClCompile Include="Sturm.cpp" />
     <ClCompile Include="Team.cpp" />
@@ -128,12 +129,10 @@
     <ClInclude Include="Schild.h" />
     <ClInclude Include="Schuh.h" />
     <ClInclude Include="Spieler.h" />
-    <ClInclude Include="SpielerStatistik.h" />
     <ClInclude Include="SSKlient.h" />
     <ClInclude Include="Statistik.h" />
     <ClInclude Include="StrengthRune.h" />
     <ClInclude Include="Sturm.h" />
-    <ClInclude Include="TeamStatistik.h" />
     <ClInclude Include="TempoRune.h" />
     <ClInclude Include="Trigger.h" />
     <ClInclude Include="Bariere.h" />

StickmanWorldOnline/StickmanWorldOnline.vcxproj.filters

@@ -135,6 +135,9 @@
     <ClCompile Include="Aktionen.cpp">
       <Filter>Spiel\Auslöser</Filter>
     </ClCompile>
+    <ClCompile Include="Statistik.cpp">
+      <Filter>Statistik</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="SpielKlasse.h">
@@ -215,12 +218,6 @@
     <ClInclude Include="Statistik.h">
       <Filter>Statistik</Filter>
     </ClInclude>
-    <ClInclude Include="SpielerStatistik.h">
-      <Filter>Statistik</Filter>
-    </ClInclude>
-    <ClInclude Include="TeamStatistik.h">
-      <Filter>Statistik</Filter>
-    </ClInclude>
     <ClInclude Include="SSKlient.h">
       <Filter>Netzwerk</Filter>
     </ClInclude>

StickmanWorldOnline/TeamStatistik.h

@@ -1,6 +0,0 @@
-#pragma once
-
-class TeamStatistik
-{
-
-};

StickmanWorldOnline/Timer.cpp

@@ -19,16 +19,21 @@ void Timer::start( Spiel *zSpiel, bool restart )
 {
     if( runns && !restart )
         return;
-    Ereignis *e = new Ereignis( TIMER_BEGINNT );
-    e->addParameter( "Betroffener Timer", this->getThis() );
-    zSpiel->throwEvent( e );
     currentTime = (float)maxZeit;
     runns = true;
     pause = 0;
+    zSpiel->setTimerZuletztGestartet( (Timer *)getThis() );
+    Ereignis *e = new Ereignis( TIMER_BEGINNT );
+    e->addParameter( "Betroffener Timer", this->getThis() );
+    zSpiel->throwEvent( e );
 }
 
-void Timer::setPause( bool pause )
+void Timer::setPause( Spiel *zSpiel, bool pause )
 {
+    if( pause && !this->pause )
+        zSpiel->setTimerZuletztPausiert( (Timer *)getThis() );
+    if( !pause && this->pause )
+        zSpiel->setTimerZuletztFortgesetzt( (Timer *)getThis() );
     this->pause = pause;
 }
 
@@ -59,10 +64,11 @@ void Timer::tick( double time, Spiel *zSpiel )
         currentTime -= (float)time;
         if( currentTime <= 0 )
         {
+            zSpiel->setTimerZuletztAbgelaufen( (Timer *)getThis() );
+            runns = 0;
             Ereignis *e = new Ereignis( TIMER_RUNNS_OUT );
             e->addParameter( "Betroffener Timer", this->getThis() );
             zSpiel->throwEvent( e );
-            runns = 0;
             if( autoWiederhohlung )
                 start( zSpiel );
         }

StickmanWorldOnline/Timer.h

@@ -20,7 +20,7 @@ private:
 public:
     Timer( int id, const char *name, int maxZeit, int x, int y, bool visible = 1, bool autoWiederhohlung = 0, bool runns = 0, int farbe = 0xFFFFFFFF );
     void start( Spiel *zSpiel, bool restart = 0 );
-    void setPause( bool pause );
+    void setPause( Spiel *zSpiel, bool pause );
     void setMaxZeit( int sekunden );
     void setAutoWiederhohlung( bool wiederhohlung );
     void setSichtbar( bool visible );

StickmanWorldOnline/Tunnel.cpp

@@ -1,4 +1,5 @@
 #include "Tunnel.h"
+#include "Spiel.h"
 
 
 Tunnel::Tunnel( int id, int x, int y, int width, int height, int zielX, int zielY, bool aktiv )
@@ -21,8 +22,9 @@ void Tunnel::setZielY( int y )
     zielY = y;
 }
 
-void Tunnel::addBenutzung()
+void Tunnel::addBenutzung( Spiel *zSpiel )
 {
+    zSpiel->setTunnelZuletztBenutzt( (Tunnel *)getThis() );
     benutzt++;
 }
 

StickmanWorldOnline/Tunnel.h

@@ -2,6 +2,8 @@
 
 #include "GameObject.h"
 
+class Spiel;
+
 class Tunnel : public GameObject
 {
 private:
@@ -15,7 +17,7 @@ public:
     Tunnel( int id, int x, int y, int width, int height, int zielX, int zielY, bool aktiv );
     void setZielX( int x );
     void setZielY( int y );
-    void addBenutzung();
+    void addBenutzung( Spiel *zSpiel );
     void setAktiv( bool aktiv );
     int getZielX() const;
     int getZielY() const;

StickmanWorldOnline/Umlenkung.cpp

@@ -1,4 +1,5 @@
 #include "Umlenkung.h"
+#include "Spiel.h"
 
 
 Umlenkung::Umlenkung( int id, int x, int y, int breite, int height, Richtung richtung, int maxAbklingzeit, bool drehend, bool aktiv )
@@ -33,7 +34,7 @@ void Umlenkung::setRichtung( Richtung r )
     this->richtung = r;
 }
 
-void Umlenkung::addBenutzt()
+void Umlenkung::addBenutzt( Spiel *zSpiel )
 {
     benutzt++;
     if( drehend )
@@ -57,6 +58,7 @@ void Umlenkung::addBenutzt()
         }
     }
     abklingzeitVerbleibend = (float)maxAbklingzeit;
+    zSpiel->setUmlenkungZuletztBenutzt( (Umlenkung *)getThis() );
 }
 
 void Umlenkung::tick( double time )

StickmanWorldOnline/Umlenkung.h

@@ -2,6 +2,8 @@
 
 #include "GameObject.h"
 
+class Spiel;
+
 class Umlenkung : public GameObject
 {
 private:
@@ -19,7 +21,7 @@ public:
     void setAktiv( bool aktiv );
     void setDrehend( bool drehend );
     void setRichtung( Richtung r );
-    void addBenutzt();
+    void addBenutzt( Spiel *zSpiel );
     void tick( double time );
     bool isAktive() const;
     bool hatAbklingzeit() const;