publish private projects

Linux Test/Linux Test.vcxproj

@@ -43,6 +43,7 @@
     <ApplicationTypeRevision>1.0</ApplicationTypeRevision>
     <TargetLinuxPlatform>Generic</TargetLinuxPlatform>
     <LinuxProjectType>{2238F9CD-F817-4ECC-BD14-2524D2669B35}</LinuxProjectType>
+    <ProjectName>LinuxTest</ProjectName>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
@@ -59,6 +60,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <UseDebugLibraries>true</UseDebugLibraries>
+    <RemoteRootDir>/home/kolja/projects</RemoteRootDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <UseDebugLibraries>false</UseDebugLibraries>
@@ -74,9 +76,28 @@
   <ImportGroup Label="Shared" />
   <ImportGroup Label="PropertySheets" />
   <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <OutDir>$(ProjectDir)bin\$(Platform)\debug\</OutDir>
+    <IntDir>$(ProjectDir)obj\$(Platform)\debug\</IntDir>
+    <TargetExt />
+    <RemoteProjectDir>$(RemoteRootDir)/Test/$(ProjectName)/debug</RemoteProjectDir>
+    <IncludePath>..\..\Framework;..\..\Network\Network;..\..\sql\sql;../../../Framework/debug;../../../Network/debug;../../../sql/debug;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="Spieler.cpp" />
+  </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="Spieler.h" />
   </ItemGroup>
-  <ItemDefinitionGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <AdditionalLibraryDirectories>$(RemoteRootDir)/sql/debug/bin/x64/debug;$(RemoteRootDir)/Network/debug/bin/x64/debug;$(RemoteRootDir)/Framework/debug/bin/x64/debug;/usr/lib/;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <LibraryDependencies>dbgFramework;dbgNetwork;dbgSQL;pq;pthread;ssl</LibraryDependencies>
+      <SharedLibrarySearchPath>%(Link.SharedLibrarySearchPath)</SharedLibrarySearchPath>
+      <AdditionalOptions>-Wl,-rpath,../lib %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets" />
 </Project>

Linux Test/Spieler.cpp

@@ -0,0 +1,496 @@
+#include "Spieler.h"
+
+#include <iostream>
+// Inhalt der Spieler Klasse aus Spieler.h
+// Konstruktor
+Spieler::Spieler()
+    : Model2DObject()
+{
+    accountId = 0;
+    sNum = 1;
+    farbe = 0;
+    for( int i = 0; i < T_MAX; i++ )
+        tastatur[ i ] = 0;
+    amLeben = 1;
+    schussAbk = 0;
+    energieAbk = 0;
+    repAbk = 0;
+    reinkAbk = 0;
+    maxReinkAbk = 5;
+    startPos = Vertex( 0, 0 );
+    setPosition( startPos );
+    setDrehung( (float)0 );
+    beschleunigung = 14;
+    beschleunigungStart = 14;
+    energie = 100;
+    stability = 100;
+    reparatur = 0;
+    laserIntensity = 30;
+    laserEffizienz = 20;
+    akkuLeistung = 4;
+    akkuLeistungStart = 4;
+    maxEnergie = 100;
+    maxStability = 100;
+    laserTempo = 200;
+    netzwerk = 0;
+    wendigkeit = 5;
+    wendigkeitStart = 5;
+    antriebEffizienz = 100;
+    energieSchild = 0;
+    energieSchildEffizienz = 0;
+    skillPunkte = 10;
+    schadenBekommen = 0;
+    schadenGemacht = 0;
+    treibstoffVerbraucht = 0;
+    shots = 0;
+    treffer = 0;
+    punkte = 0;
+    kills = 0;
+    tode = 0;
+    zeitAmLeben = 0;
+    zeitTod = 0;
+    needWiederbelebung = 0;
+}
+
+// Destruktor
+Spieler::~Spieler()
+{}
+
+// nicht constant
+void Spieler::offline()
+{}
+
+void Spieler::online( SSKlientV *zKlient )
+{}
+
+void Spieler::setModelData( Model2DData *data )
+{
+    for( auto i = data->polygons->getIterator(); i; i++ )
+    {
+        if( i._.name->istGleich( "engine_l" ) )
+        {
+            stL = *i._.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i._.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i._.tKordinaten->get( j ).x == 0.f )
+                        l = i._.vertex->get( j );
+                    if( i._.tKordinaten->get( j ).x == 1.f )
+                        r = i._.vertex->get( j );
+                }
+            }
+            kL = ( ( l + ( r - l ) * 0.5 ) - stL );
+        }
+        if( i._.name->istGleich( "engine_r" ) )
+        {
+            stR = *i._.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i._.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i._.tKordinaten->get( j ).x == 0.f )
+                        l = i._.vertex->get( j );
+                    if( i._.tKordinaten->get( j ).x == 1.f )
+                        r = i._.vertex->get( j );
+                }
+            }
+            kR = ( ( l + ( r - l ) * 0.5 ) - stR );
+        }
+        if( i._.name->istGleich( "engine_m" ) )
+        {
+            stM = *i._.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i._.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i._.tKordinaten->get( j ).x == 0.f )
+                        l = i._.vertex->get( j );
+                    if( i._.tKordinaten->get( j ).x == 1.f )
+                        r = i._.vertex->get( j );
+                }
+            }
+            kM = ( ( l + ( r - l ) * 0.5 ) - stM );
+        }
+    }
+    kL.normalize();
+    kR.normalize();
+    kM.normalize();
+    setModel( data );
+}
+
+void Spieler::setAccountId( int id )
+{
+    accountId = id;
+}
+
+void Spieler::setSpielerFarbe( int farbe )
+{
+    this->farbe = farbe;
+}
+
+bool Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
+{
+    if( tastatur[ ts ] == aktiv || !amLeben )
+        return 0;
+    tastatur[ ts ] = aktiv;
+    return 1;
+}
+
+bool Spieler::tick( double zeit )
+{
+    reinkAbk -= zeit;
+    if( reinkAbk < 0 )
+        reinkAbk = 0;
+    if( !reinkAbk && !amLeben )
+    { // Wiederbelebung
+        needWiederbelebung = 1;
+        return 0;
+    }
+    if( amLeben )
+    {
+        schussAbk -= zeit;
+        energieAbk -= zeit;
+        if( schussAbk < 0 )
+            schussAbk = 0;
+        if( energieAbk < 0 )
+            energieAbk = 0;
+        repAbk -= zeit;
+        if( repAbk < 0 )
+            repAbk = 0;
+        if( tastatur[ T_GAS ] )
+        {
+            double treibstoff = 0.5 * ( ( beschleunigung ) / 5 )
+                * zeit * ( 100 / ( antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            float factor = 1;
+            if( treibstoff > energie )
+                factor = (float)( energie / treibstoff );
+            float tmp2 = (float)zeit * (float)(beschleunigung) * factor;
+            Vertex tmp = getWorldDir( kM );
+            tmp = tmp * tmp2;
+            impuls( getWorldPos( stM ), tmp );
+            energie -= treibstoff * factor;
+        }
+        if( tastatur[ T_ROT_R ] )
+        {
+            double treibstoff = 0.25 * ( ( wendigkeit ) / 5 )
+                * zeit * ( 100 / ( antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            float factor = 1;
+            if( treibstoff > energie )
+                factor = (float)( energie / treibstoff );
+            impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)zeit * (float)(wendigkeit)* factor );
+            energie -= treibstoff * factor;
+        }
+        if( tastatur[ T_ROT_L ] )
+        {
+            double treibstoff = 0.25 * ( ( wendigkeit ) / 5 )
+                * zeit * ( 100 / ( antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            float factor = 1;
+            if( treibstoff > energie )
+                factor = (float)( energie / treibstoff );
+            impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)zeit * (float)(wendigkeit)* factor );
+            energie -= treibstoff * factor;
+        }
+        WeltInfo info;
+        info.circular = 0;
+        info.hasSize = 0;
+        info.airResistance = 0.001f;
+        Model2DObject::tick( info, zeit );
+        if( !energieAbk )
+        {
+            energie += (akkuLeistung)* zeit;
+            if( energie > ( maxEnergie ) )
+                energie = ( maxEnergie );
+        }
+        if( !repAbk )
+        {
+            stability += (reparatur)* zeit;
+            if( stability > ( maxStability ) )
+                stability = ( maxStability );
+        }
+        zeitAmLeben += zeit;
+    }
+    else
+        zeitTod += zeit;
+    return 0;
+}
+
+bool Spieler::setSkill( int art )
+{
+    if( !skillPunkte )
+        return 0;
+    skillPunkte--;
+    switch( art )
+    {
+    case 0: // Max Stabilität
+        maxStability += 10;
+        stability += 10;
+        break;
+    case 1: // Max Energie
+        maxEnergie += 10;
+        break;
+    case 2: // Reparatur
+        reparatur += 0.15;
+        break;
+    case 3: // Laser Intensität
+        laserIntensity += 3;
+        break;
+    case 4: // Laser Effizienz
+        laserEffizienz += 1;
+        break;
+    case 5: // Laser Tempo
+        laserTempo += 20;
+        break;
+    case 6: // Beschleunigung
+        beschleunigung += 1.75;
+        break;
+    case 7: // Wendigkeit
+        wendigkeit += 2.5;
+        break;
+    case 8: // Netzwerk
+        netzwerk += 1;
+        break;
+    case 9: // Akkuleistung
+        akkuLeistung += 0.12;
+        break;
+    case 10: // Akkuleistung
+        antriebEffizienz += 10;
+        break;
+    case 11: // Energie Schild
+        energieSchild += 1;
+        break;
+    case 12: // Energie Schild Effizienz
+        energieSchildEffizienz += 2;
+        break;
+    }
+    return 1;
+}
+
+bool Spieler::nimmSchaden( double &intensity )
+{
+    double schieldVal = intensity / 100 * energieSchild;
+    double schieldEVal = schieldVal - schieldVal / 100 * energieSchildEffizienz;
+    if( schieldEVal > energie )
+    {
+        schieldEVal = energie;
+        schieldVal = schieldEVal / ( 1 - ( energieSchildEffizienz / 100 ) );
+    }
+    intensity -= schieldVal;
+    std::cout << "Schaden: " << intensity << " ";
+    energie -= schieldEVal;
+    stability -= intensity;
+    std::cout << "Stabilität: " << stability << "\n";
+    schadenBekommen += intensity;
+    repAbk = 2;
+    if( stability <= 0 )
+    {
+        amLeben = 0;
+        setCollision( 0 );
+        tode++;
+        stability = 0;
+        reinkAbk += maxReinkAbk;
+        maxReinkAbk++;
+        punkte--;
+    }
+    return stability == 0;
+}
+
+void Spieler::machSchaden( double intensity, bool kill )
+{
+    schadenGemacht += intensity;
+    treffer++;
+    if( kill )
+    {
+        skillPunkte += 2;
+        kills++;
+        punkte++;
+        maxReinkAbk--;
+        if( maxReinkAbk < 5 )
+            maxReinkAbk = 5;
+    }
+}
+
+void Spieler::wiederbeleben()
+{
+    needWiederbelebung = 0;
+    setPosition( startPos );
+    reinkAbk = maxReinkAbk * 2;
+    energie = maxEnergie;
+    stability = maxStability;
+    schussAbk = 0;
+    energieAbk = 0;
+    repAbk = 0;
+    setSpeed( 0, 0 );
+    setDrehung( 0 );
+    setDrehungSpeed( 0 );
+    for( int i = 0; i < T_MAX; i++ )
+        tastatur[ i ] = 0;
+    amLeben = 1;
+    setCollision( 1 );
+}
+
+// constant
+int Spieler::getAccountId() const
+{
+    return accountId;
+}
+
+bool Spieler::istTreffer( Vec2< float > pos ) const
+{
+    if( !amLeben )
+        return 0;
+    return istPunktInnen( pos );
+}
+
+// Raumschiff Eigenschaften
+double Spieler::getTeamMaxEnergieBonus() const
+{
+    return maxEnergie / 100 * netzwerk;
+}
+
+double Spieler::getTeamMaxStabilityBonus() const
+{
+    return maxStability / 100 * netzwerk;
+}
+
+double Spieler::getTeamReparaturBonus() const
+{
+    return reparatur / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserIntensityBonus() const
+{
+    return laserIntensity / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserEffizienzBonus() const
+{
+    return laserEffizienz / 100 * netzwerk;
+}
+
+double Spieler::getTeamAkkuLeistungBonus() const
+{
+    return akkuLeistung / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserTempoBonus() const
+{
+    return laserTempo / 100 * netzwerk;
+}
+
+double Spieler::getTeamBeschleunigungBonus() const
+{
+    return beschleunigung / 100 * netzwerk;
+}
+
+double Spieler::getTeamWendigkeitBonus() const
+{
+    return wendigkeit / 100 * netzwerk;
+}
+
+double Spieler::getTeamAntriebEffizienzBonus() const
+{
+    return antriebEffizienz / 100 * netzwerk;
+}
+
+double Spieler::getTeamEnergieSchildBonus() const
+{
+    return energieSchild / 100 * netzwerk;
+}
+
+double Spieler::getTeamEnergieSchildEffizienzBonus() const
+{
+    return energieSchildEffizienz / 100 * netzwerk;
+}
+
+bool Spieler::istAmLeben() const
+{
+    return amLeben;
+}
+
+// Statistik Werte
+int Spieler::getSpielerNummer() const
+{
+    return sNum;
+}
+
+int Spieler::getSpielerFarbe() const
+{
+    return farbe;
+}
+
+int Spieler::getSchadenBekommen() const
+{
+    return (int)schadenBekommen;
+}
+
+int Spieler::getSchadenGemacht() const
+{
+    return (int)schadenGemacht;
+}
+
+int Spieler::getTreibstoffVerbraucht() const
+{
+    return (int)treibstoffVerbraucht;
+}
+
+int Spieler::getShots() const
+{
+    return shots;
+}
+
+int Spieler::getTreffer() const
+{
+    return treffer;
+}
+
+int Spieler::getPunkte() const
+{
+    return punkte;
+}
+
+int Spieler::getKills() const
+{
+    return kills;
+}
+
+int Spieler::getTode() const
+{
+    return tode;
+}
+
+int Spieler::getZeitAmLeben() const
+{
+    return (int)zeitAmLeben;
+}
+
+int Spieler::getZeitTod() const
+{
+    return (int)zeitTod;
+}
+
+bool Spieler::doNeedWiederbelebung() const
+{
+    return needWiederbelebung;
+}
+
+// Reference Counting
+Spieler *Spieler::getThis()
+{
+    ref++;
+    return this;
+}
+
+Spieler *Spieler::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

Linux Test/Spieler.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include <Bild.h>
+#include <Model2D.h>
+
+class Klient;
+class SSKlientV;
+
+using namespace Framework;
+
+enum TastaturStatus
+{
+    T_GAS,
+    T_ROT_L,
+    T_ROT_R,
+    T_FEUER,
+    T_MAX
+};
+
+class Spieler : public Model2DObject
+{
+private:
+    // antrieb
+    Vertex stL;
+    Vertex kL;
+    Vertex stR;
+    Vertex kR;
+    Vertex stM;
+    Vertex kM;
+
+    int accountId;
+    int sNum;
+    int farbe;
+    bool tastatur[ T_MAX ];
+    bool amLeben;
+    double schussAbk;
+    double energieAbk;
+    double repAbk;
+    double reinkAbk;
+    int maxReinkAbk;
+    // Raumschiff Eigenschaftend
+    Vertex startPos;
+    double beschleunigung;
+    double beschleunigungStart;
+    double energie;
+    double stability;
+    double reparatur;
+    double laserIntensity;
+    double laserEffizienz;
+    double akkuLeistung;
+    double akkuLeistungStart;
+    double maxEnergie;
+    double maxStability;
+    double laserTempo;
+    double netzwerk;
+    double wendigkeit;
+    double wendigkeitStart;
+    double antriebEffizienz;
+    double energieSchild;
+    double energieSchildEffizienz;
+    int skillPunkte;
+    // Statistik Werte
+    double schadenBekommen;
+    double schadenGemacht;
+    double treibstoffVerbraucht;
+    int shots;
+    int treffer;
+    int punkte;
+    int kills;
+    int tode;
+    double zeitAmLeben;
+    double zeitTod;
+    bool needWiederbelebung;
+
+public:
+    // Konstruktor
+    Spieler();
+    // Destruktor
+    ~Spieler();
+    // nicht constant
+    void offline();
+    void online( SSKlientV *zKlient );
+    void setModelData( Model2DData *data );
+    void setAccountId( int id );
+    void setSpielerFarbe( int farbe );
+    bool setTastataturStatus( TastaturStatus ts, bool aktiv );
+    bool tick( double zeit );
+    bool setSkill( int art );
+    bool nimmSchaden( double &intensity );
+    void machSchaden( double intensity, bool kill );
+    void wiederbeleben();
+    // constant
+    int getAccountId() const;
+    bool istOnline() const;
+    bool istTreffer( Vec2< float > pos ) const;
+    // Raumschiff Eigenschaften
+    double getTeamMaxEnergieBonus() const;
+    double getTeamMaxStabilityBonus() const;
+    double getTeamReparaturBonus() const;
+    double getTeamLaserIntensityBonus() const;
+    double getTeamLaserEffizienzBonus() const;
+    double getTeamAkkuLeistungBonus() const;
+    double getTeamLaserTempoBonus() const;
+    double getTeamBeschleunigungBonus() const;
+    double getTeamWendigkeitBonus() const;
+    double getTeamAntriebEffizienzBonus() const;
+    double getTeamEnergieSchildBonus() const;
+    double getTeamEnergieSchildEffizienzBonus() const;
+    bool istAmLeben() const;
+    // Statistik Werte
+    int getSpielerNummer() const;
+    int getSpielerFarbe() const;
+    int getSchadenBekommen() const;
+    int getSchadenGemacht() const;
+    int getTreibstoffVerbraucht() const;
+    int getShots() const;
+    int getTreffer() const;
+    int getPunkte() const;
+    int getKills() const;
+    int getTode() const;
+    int getZeitAmLeben() const;
+    int getZeitTod() const;
+    bool doNeedWiederbelebung() const;
+    // Reference Counting
+    Spieler *getThis();
+    Spieler *release();
+};

Linux Test/main.cpp

@@ -0,0 +1,86 @@
+#include <Globals.h>
+#include <Server.h>
+#include <Vec2.h>
+#include "Spieler.h"
+#include <M2Datei.h>
+
+using namespace Network;
+
+float randomFloat()
+{
+    float r = (float)rand();
+    float r2 = (float)rand();
+    float r3 = (float)rand();
+    return r * r2 / r3;
+}
+
+int main()
+{
+    Vertex v = Vertex( 1e-23, 0 );
+    float length = v.getLength();
+    v.normalize();
+    Framework::initFramework();
+    Network::Start( 1 );
+    Framework::M2Datei dat;
+    dat.setPfad( "/test/spiele/3/models/ship.m2" );
+    dat.leseDaten();
+    Model2DData *data = dat.ladeModel( "ship" );
+    Server *s = new Server();
+    s->verbinde( 11788, 1 );
+    while( true )
+    {
+        SKlient *k = s->getKlient();
+        Spieler s;
+        s.setTastataturStatus( T_GAS, 1 );
+        s.setModelData( data->getThis() );
+        int count = 0;
+        while( true )
+        {
+            count++;
+            if( count == 11788 )
+            {
+                int x = 0;
+            }
+            s.tick( 0.03333333 );
+            float r = (float)rand() / (float)RAND_MAX;
+            char calc = (char)(r * 10);
+            switch( calc )
+            {
+            case 0:
+                s.setTastataturStatus( T_GAS, 1 );
+                break;
+            case 1:
+                s.setTastataturStatus( T_GAS, 0 );
+                break;
+            case 2:
+                s.setTastataturStatus( T_ROT_L, 1 );
+                break;
+            case 3:
+                s.setTastataturStatus( T_ROT_L, 0 );
+                break;
+            case 4:
+                s.setTastataturStatus( T_ROT_R, 1 );
+                break;
+            case 5:
+                s.setTastataturStatus( T_ROT_R, 0 );
+                break;
+            }
+            char buff[ 25 ];
+            *(float*)buff = s.getPosition().x;
+            *(float*)( buff + 4 ) = s.getPosition().y;
+            *(float*)( buff + 8 ) = s.getSpeed().x;
+            *(float*)( buff + 12 ) = s.getSpeed().y;
+            *(float*)( buff + 16 ) = s.getDrehung();
+            *(float*)( buff + 20 ) = s.getDrehungSpeed();
+            *( buff + 24 ) = calc;
+            if( !k->sende( buff, 25 ) )
+                break;
+        }
+        k->release();
+    }
+    data->release();
+    s->release();
+    Network::Exit();
+    Framework::releaseFramework();
+    return 0;
+}