Linux-Test/Linux Test/Spieler.cpp

#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;
}