Asteroids-Online-Client/Asteroids/Spiel/Spieler/Spieler.cpp

#include "Spieler.h"
#include "../../Initialisierung/Initialisierung.h"
#include "../Karte/Karte.h"
#include "../Define.h"
#include <Textur2D.h>
#include "../Schuss/Laser.h"

// Inhalt der Spieler Klasse aus Spieler.h
// Konstruktor
Spieler::Spieler( KSGClient::InformationServerClient* zInfoK, UIInit& uiFactory, SpielerStr* zStr )
    : Model2DObject()
{
    activeSkills = new RCArray< ActiveSkill >();
    deadPlayer = 0;
    accountId = 0;
    sNum = zStr->id;
    farbe = 0;
    zteam = 0;
    info = dynamic_cast<KSGClient::InformationServerClient*>(zInfoK->getThis());
    name = 0;
    for( int i = 0; i < T_MAX; i++ )
        tastatur[ i ] = 0;
    level = 1;
    amLeben = 1;
    schussAbk = 0;
    energieAbk = 0;
    repAbk = 0;
    reinkAbk = 0;
    maxReinkAbk = 5;
    startPos = zStr->pos;
    setPosition( startPos );
    setDrehung( (float)zStr->rot );
    beschleunigung = zStr->beschleunigung;
    energie = zStr->maxEnergie;
    stabilität = zStr->maxStabilität;
    reparatur = zStr->reparatur;
    laserIntensität = zStr->laserIntensität;
    laserEffizienz = zStr->laserEffizienz;
    akkuLeistung = zStr->akkuLeistung;
    maxEnergie = zStr->maxEnergie;
    maxStabilität = zStr->maxStabilität;
    laserTempo = zStr->laserTempo;
    netzwerk = zStr->netzwerk;
    wendigkeit = zStr->wendigkeit;
    antriebEffizienz = zStr->antriebEffizienz;
    energieSchild = zStr->energieSchild;
    energieSchildEffizienz = zStr->energieSchildEffizienz;
    skillPunkte = zStr->skillPunkte;
    schadenBekommen = 0;
    schadenGemacht = 0;
    treibstoffVerbraucht = 0;
    schüsse = 0;
    treffer = 0;
    punkte = 0;
    kills = 0;
    tode = 0;
    zeitAmLeben = 0;
    zeitTod = 0;
    nText = initTextFeld( 0, 0, 152, 30, uiFactory, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
                          TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
    ep = 0;
    nextSkillEp = 80;
    save();
}

// Destruktor
Spieler::~Spieler()
{
    info->release();
    if( name )
        name->release();
    flammenL->release();
    flammenR->release();
    flammenM->release();
    nText->release();
    if( deadPlayer )
        deadPlayer->release();
    activeSkills->release();
}

double Spieler::calculateBeschleunigung()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getBeschleunigungFactor();
        bonus += s->getBeschleunigungBonus();
    }
    return (beschleunigung + zteam->beschleunigung) * factor + bonus;
}

double Spieler::calculateReparatur()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getReparaturFactor();
        bonus += s->getReparaturBonus();
    }
    return (reparatur + zteam->reparatur) * factor + bonus;
}

double Spieler::calculateLaserIntensität()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getLaserIntensitätFactor();
        bonus += s->getLaserIntensitätBonus();
    }
    return (laserIntensität + zteam->laserIntensität) * factor + bonus;
}

double Spieler::calculateLaserEffizienz()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getLaserEffizienzFactor();
        bonus += s->getLaserEffizienzBonus();
    }
    return (laserEffizienz + zteam->laserEffizienz) * factor + bonus;
}

double Spieler::calculateAkkuLeistung()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getAkkuLeistungFactor();
        bonus += s->getAkkuLeistungBonus();
    }
    return (akkuLeistung + zteam->akkuLeistung) * factor + bonus;
}

double Spieler::calculateMaxEnergie()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getMaxEnergieFactor();
        bonus += s->getMaxEnergieBonus();
    }
    return (maxEnergie + zteam->maxEnergie) * factor + bonus;
}

double Spieler::calculateMaxStabilität()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getMaxStabilitätFactor();
        bonus += s->getMaxStabilitätBonus();
    }
    return (maxStabilität + zteam->maxStabilität) * factor + bonus;
}

double Spieler::calculateLaserTempo()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getLaserTempoFactor();
        bonus += s->getLaserTempoBonus();
    }
    return (laserTempo + zteam->laserTempo) * factor + bonus;
}

double Spieler::calculateWendigkeit()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getWendigkeitFactor();
        bonus += s->getWendigkeitBonus();
    }
    return (wendigkeit + zteam->wendigkeit) * factor + bonus;
}

double Spieler::calculateAntriebEffizienz()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getAntriebEffizienzFactor();
        bonus += s->getAntriebEffizienzBonus();
    }
    return (antriebEffizienz + zteam->antriebEffizienz) * factor + bonus;
}

double Spieler::calculateEnergieSchild()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getEnergieSchildFactor();
        bonus += s->getEnergieSchildBonus();
    }
    return (energieSchild + zteam->energieSchild) * factor + bonus;
}

double Spieler::calculateEnergieSchildEffizienz()
{
    double factor = 1;
    double bonus = 0;
    for( auto s : *activeSkills )
    {
        factor *= s->getEnergieSchildEffizienzFactor();
        bonus += s->getEnergieSchildEffizienzBonus();
    }
    return (energieSchildEffizienz + zteam->energieSchildEffizienz) * factor + bonus;
}

double Spieler::calculateLaserCost()
{
    double kosten = (calculateLaserIntensität() / 2 +
                      calculateLaserTempo() / 9) *
        (1 / (calculateLaserEffizienz() / 25));
    if( kosten < 1 )
        kosten = 1;
    return kosten;
}

// nicht constant
void Spieler::addSkill( ActiveSkill* skill )
{
    activeSkills->add( skill );
}

void Spieler::useSkill( int id )
{
    if( activeSkills->z( id ) )
        activeSkills->z( id )->activate();
}

void Spieler::setModelData( Model2DData* data, Animation2DData* zFStart, Animation2DData* zFBurn )
{
    for( auto i : *data->polygons )
    {
        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 );
    flammenM = new Textur2D();
    flammenM->addAnimationZ( dynamic_cast<Animation2DData*>(zFStart->getThis()) );
    flammenM->addAnimationZ( dynamic_cast<Animation2DData*>(zFBurn->getThis()) );
    flammenL = new Textur2D();
    flammenL->addAnimationZ( dynamic_cast<Animation2DData*>(zFStart->getThis()) );
    flammenL->addAnimationZ( dynamic_cast<Animation2DData*>(zFBurn->getThis()) );
    flammenR = new Textur2D();
    flammenR->addAnimationZ( dynamic_cast<Animation2DData*>(zFStart->getThis()) );
    flammenR->addAnimationZ( dynamic_cast<Animation2DData*>(zFBurn->getThis()) );
    setTextur( dynamic_cast<Textur2D*>(flammenL->getThis()), "engine_l" );
    setTextur( dynamic_cast<Textur2D*>(flammenR->getThis()), "engine_r" );
    setTextur( dynamic_cast<Textur2D*>(flammenM->getThis()), "engine_m" );
}

void Spieler::setAccountId( int accId )
{
    accountId = accId;
    name = info->getSpielerName( accountId );
    if( name )
        nText->setText( *name );
}

void Spieler::setTeam( Team* zTeam )
{
    this->zteam = zTeam;
    nText->setHintergrundFarbe( 0xA0000000 | (zteam->farbe & 0x00FFFFFF) );
    nText->setRahmenFarbe( zteam->farbe );
}

void Spieler::setSpielerFarbe( int fc, Bild* zTextur )
{
    farbe = fc;
    nText->setSchriftFarbe( fc );
    Bild* shb = new Bild();
    shb->neuBild( zTextur->getBreite(), zTextur->getHeight(), 0 );
    int maxP = shb->getBreite() * shb->getHeight();
    int* buffer = zTextur->getBuffer();
    for( int i = 0; i < maxP; i++ )
    {
        if( buffer[ i ] )
        {
            shb->setPixelDP( i, fc );
            shb->alphaPixelDP2D( i, buffer[ i ] );
        }
    }
    Textur2D* textur = new Textur2D();
    textur->setTexturZ( shb );
    setTextur( textur, "ship" );
}

void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
{
    if( !amLeben )
    {
        tastatur[ ts ] = aktiv;
        return;
    }
    tastatur[ ts ] = aktiv;
    if( flammenM && flammenR && flammenL )
    {
        switch( ts )
        {
        case T_GAS:
            if( aktiv )
                flammenM->setAnimation( 0 );
            else
                flammenM->setAnimation( -1 );
            break;
        case T_ROT_L:
            if( aktiv )
                flammenR->setAnimation( 0 );
            else
                flammenR->setAnimation( -1 );
            break;
        case T_ROT_R:
            if( aktiv )
                flammenL->setAnimation( 0 );
            else
                flammenL->setAnimation( -1 );
            break;
        }
    }
}

bool Spieler::tick( const WeltInfo& info, double tv )
{
    bool ret = 0;
    if( !zteam )
        return 0;
    tv = TICK;
    reinkAbk -= tv;
    if( reinkAbk < 0 )
        reinkAbk = 0;
    flammenM->tick( tv );
    flammenL->tick( tv );
    flammenR->tick( tv );
    if( amLeben )
    {
        for( auto s : *activeSkills )
            s->tick( tv );
        schussAbk -= tv;
        energieAbk -= tv;
        if( schussAbk < 0 )
            schussAbk = 0;
        if( energieAbk < 0 )
            energieAbk = 0;
        repAbk -= tv;
        if( repAbk < 0 )
            repAbk = 0;
        if( tastatur[ T_GAS ] )
        {
            double treibstoff = 0.5 * (calculateBeschleunigung() / 15)
                * tv * (100 / calculateAntriebEffizienz());
            treibstoffVerbraucht += treibstoff;
            float factor = 1;
            if( treibstoff > energie )
                factor = (float)(energie / treibstoff);
            if( factor > 0 )
                impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)tv * (float)calculateBeschleunigung() * factor );
            energie -= treibstoff * factor;
        }
        if( tastatur[ T_ROT_R ] )
        {
            double treibstoff = 0.25 * (calculateWendigkeit() / 15)
                * tv * (100 / calculateAntriebEffizienz());
            treibstoffVerbraucht += treibstoff;
            float factor = 1;
            if( treibstoff > energie )
                factor = (float)(energie / treibstoff);
            if( factor > 0 )
                impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)tv * (float)calculateWendigkeit() * factor );
            energie -= treibstoff * factor;
        }
        if( tastatur[ T_ROT_L ] )
        {
            double treibstoff = 0.25 * (calculateWendigkeit() / 15)
                * tv * (100 / calculateAntriebEffizienz());
            treibstoffVerbraucht += treibstoff;
            float factor = 1;
            if( treibstoff > energie )
                factor = (float)(energie / treibstoff);
            if( factor > 0 )
                impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)tv * (float)calculateWendigkeit() * factor );
            energie -= treibstoff * factor;
        }
        __super::tick( info, tv );
        if( !energieAbk )
        {
            if( energie != calculateMaxEnergie() )
                ret = 1;
            energie += calculateAkkuLeistung() * tv;
            if( energie > calculateMaxEnergie() )
                energie = calculateMaxEnergie();
        }
        if( !repAbk )
        {
            if( stabilität != calculateMaxStabilität() )
                ret = 1;
            stabilität += calculateReparatur() * tv;
            if( stabilität > calculateMaxStabilität() )
                stabilität = calculateMaxStabilität();
        }
        zeitAmLeben += tv;
    }
    else
        zeitTod += tv;
    return ret;
}

void Spieler::render( Mat3< float >& kamMat, Bild& zRObj, const char* kamName )
{
    if( !amLeben )
        return;
    __super::render( kamMat, zRObj, kamName );
    if( Text( "minimap" ).istGleich( kamName ) )
        return;
    renderLeben( kamMat, zRObj );
}

void Spieler::renderLeben( const Mat3< float >& kamMat, Bild& zRObj )
{
    if( !zteam || !amLeben )
        return;
    nText->setPosition( (Punkt)(kamMat * getPosition() - Vertex( 76, (zModel()->maxP.y * getSize()) + 30 )) );
    if( name )
        nText->setText( Text( name->getText() ) + " (" + level + ")" );
    nText->render( zRObj );
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, zteam->farbe );
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, zteam->farbe );
    int l = (int)(stabilität * 100 / calculateMaxStabilität() * 1.5 + 0.5);
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
    int e = (int)(energie * 100 / calculateMaxEnergie() * 1.5 + 0.5);
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFF0000FF );
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFF0000FF );
    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFF0000FF );
    int e2 = (int)((energie - calculateLaserCost()) * 100 / calculateMaxEnergie() * 1.5 + 0.5);
    if( e2 > 0 )
    {
        zRObj.drawLinieV( nText->getX() + e2, nText->getY() + 26, 3, 0xFFFFFFFF );
        zRObj.drawLinieV( nText->getX() + e2 + 1, nText->getY() + 26, 3, 0xFFFFFFFF );
    }
}

void Spieler::setSkill( int art )
{
    skillPunkte--;
    switch( art )
    {
    case 0: // Max Stabilität
        maxStabilität += 10;
        stabilität += 10;
        zteam->maxStabilität = zteam->getMaxStabilitätBonus();
        break;
    case 1: // Max Energie
        maxEnergie += 10;
        zteam->maxEnergie = zteam->getMaxEnergieBonus();
        break;
    case 2: // Reparatur
        reparatur += 0.15;
        zteam->reparatur = zteam->getReperaturBonus();
        break;
    case 3: // Laser Intensität
        laserIntensität += 4;
        zteam->laserIntensität = zteam->getLaserIntensitätBonus();
        break;
    case 4: // Laser Effizienz
        laserEffizienz += 1.5;
        zteam->laserEffizienz = zteam->getLaserEffizienzBonus();
        break;
    case 5: // Laser Tempo
        laserTempo += 15;
        zteam->laserTempo = zteam->getLaserTempoBonus();
        break;
    case 6: // Beschleunigung
        beschleunigung += 10;
        zteam->beschleunigung = zteam->getBeschleunigungBonus();
        break;
    case 7: // Wendigkeit
        wendigkeit += 2.5;
        zteam->wendigkeit = zteam->getWendigkeitBonus();
        break;
    case 8: // Netzwerk
        netzwerk += 1;
        zteam->maxStabilität = zteam->getMaxStabilitätBonus();
        zteam->maxEnergie = zteam->getMaxEnergieBonus();
        zteam->reparatur = zteam->getReperaturBonus();
        zteam->laserIntensität = zteam->getLaserIntensitätBonus();
        zteam->laserEffizienz = zteam->getLaserEffizienzBonus();
        zteam->laserTempo = zteam->getLaserTempoBonus();
        zteam->beschleunigung = zteam->getBeschleunigungBonus();
        zteam->wendigkeit = zteam->getWendigkeitBonus();
        zteam->akkuLeistung = zteam->getAkkuLeistungBonus();
        zteam->antriebEffizienz = zteam->getAntriebEffizienzBonus();
        zteam->energieSchild = zteam->getEnergieSchildBonus();
        zteam->energieSchildEffizienz = zteam->getEnergieSchildEffizienzBonus();
        break;
    case 9: // Akkuleistung
        akkuLeistung += 0.12;
        zteam->akkuLeistung = zteam->getAkkuLeistungBonus();
        break;
    case 10: // Antrieb Effizienz
        antriebEffizienz += 10;
        zteam->antriebEffizienz = zteam->getAntriebEffizienzBonus();
        break;
    case 11: // Energie Schild
        energieSchild += 0.075;
        zteam->energieSchild = zteam->getEnergieSchildBonus();
        break;
    case 12: // Energie Schild Effizienz
        energieSchildEffizienz += 10;
        zteam->energieSchildEffizienz = zteam->getEnergieSchildEffizienzBonus();
        break;
    }
}

void Spieler::nimmSchaden( double& intensität, int sLevel )
{
    double originalIntens = intensität;
    double schieldVal = intensität - intensität / calculateEnergieSchild();
    double schieldEVal = schieldVal / (calculateEnergieSchildEffizienz() / 100);
    if( schieldEVal > energie )
    {
        schieldEVal = energie;
        schieldVal = schieldEVal * (calculateEnergieSchildEffizienz() / 100);
    }
    intensität -= schieldVal;
    energie -= schieldEVal;
    stabilität -= intensität;
    schadenBekommen += intensität;
    energieAbk = 1.5;
    repAbk = 2;
    if( stabilität > 0 )
    {
        float levelFactor = (float)sLevel / (float)level;
        addEp( ((float)originalIntens / 20) * levelFactor );
    }
}

void Spieler::calcDeadPlayerObject( Laser* zSchuss )
{
    Vertex hp;
    Polygon2D a;
    Polygon2D b;
    Punkt pa;
    Punkt pb;
    if( calcHitPoint( zSchuss->getPosition() - zSchuss->getSpeed(), zSchuss->getSpeed(), hp ) )
    {
        if( zModel()->split( getObjectPos( hp ), getObjectDir( zSchuss->getSpeed() ) * 0.1f, "ship", a, b, pa, pb, []() {
            return rand() / (double)RAND_MAX;
        } ) )
        {
            hp = (hp * getSize()).rotation( getDrehung() ) + getPosition();
            pa = pa.rotation( getDrehung() ) + getPosition();
            pb = pb.rotation( getDrehung() ) + getPosition();
            Array< Polygon2D >* npaA = new Array< Polygon2D >();
            npaA->add( a );
            Model2DData* npdA = new Model2DData();
            npdA->erstelleModell( npaA );
            Array< Polygon2D >* npaB = new Array< Polygon2D >();
            npaB->add( b );
            Model2DData* npdB = new Model2DData();
            npdB->erstelleModell( npaB );
            if( deadPlayer )
                deadPlayer->release();
            deadPlayer = new DeadPlayer( npdA, npdB, pa, pb, getSpeed() * (rand() / (float)RAND_MAX), getSpeed() * (rand() / (float)RAND_MAX), getDrehung(), getDrehung(), getDrehungSpeed() * (rand() / (float)RAND_MAX), getDrehungSpeed() * (rand() / (float)RAND_MAX), zTextur( "ship" ) );
        }
    }
}

void Spieler::machSchaden( double intensität, int sLevel, bool erf )
{
    schadenGemacht += intensität;
    addTreffer( (float)intensität, sLevel, erf );
}

void Spieler::addKill( int sLevel, bool erf )
{
    float levelFactor = (float)sLevel / (float)level;
    if( erf )
        addEp( 80 * levelFactor );
    kills++;
    punkte++;
    maxReinkAbk--;
    if( maxReinkAbk < 5 )
        maxReinkAbk = 5;
}

DeadPlayer* Spieler::sterben()
{
    amLeben = 0;
    setCollision( 0 );
    tode++;
    stabilität = 0;
    reinkAbk += maxReinkAbk;
    maxReinkAbk++;
    punkte--;
    return deadPlayer ? dynamic_cast<DeadPlayer*>(deadPlayer->getThis()) : 0;
}

void Spieler::wiederbelebung()
{
    for( auto s : *activeSkills )
        s->reset();
    setPosition( startPos );
    reinkAbk = maxReinkAbk * 2;
    energie = calculateMaxEnergie();
    stabilität = calculateMaxStabilität();
    schussAbk = 0;
    energieAbk = 0;
    repAbk = 0;
    setSpeed( 0, 0 );
    setDrehung( 0 );
    setDrehungSpeed( 0 );
    for( int i = 0; i < T_MAX; i++ )
        tastatur[ i ] = 0;
    flammenM->setAnimation( -1 );
    flammenL->setAnimation( -1 );
    flammenR->setAnimation( -1 );
    amLeben = 1;
    setCollision( 1 );
}

void Spieler::hatGeschossen()
{
    energie -= calculateLaserCost();
    schussAbk = 1;
    energieAbk = 1.5;
    schüsse++;
}

void Spieler::addTreffer( float indens, int sLevel, bool erf )
{
    treffer++;
    float levelFactor = (float)sLevel / (float)level;
    if( erf )
        addEp( (indens / 10) * levelFactor );
}

void Spieler::addEp( float ep )
{
    this->ep += ep;
    while( this->ep >= nextSkillEp )
    {
        level++;
        skillPunkte++;
        this->ep -= nextSkillEp;
        nextSkillEp *= 1.025f;
    }
}

void Spieler::save()
{
    last.rSpeed = getDrehungSpeed();
    last.pos = getPosition();
    last.speed = getSpeed();
    last.rotation = getDrehung();
    last.farbe = farbe;
    last.amLeben = amLeben;
    last.schussAbk = schussAbk;
    last.energieAbk = energieAbk;
    last.repAbk = repAbk;
    last.reinkAbk = reinkAbk;
    last.maxReinkAbk = maxReinkAbk;
    last.startPos = startPos;
    last.beschleunigung = beschleunigung;
    last.energie = energie;
    last.stabilität = stabilität;
    last.reparatur = reparatur;
    last.laserIntensität = laserIntensität;
    last.laserEffizienz = laserEffizienz;
    last.akkuLeistung = akkuLeistung;
    last.maxEnergie = maxEnergie;
    last.maxStabilität = maxStabilität;
    last.laserTempo = laserTempo;
    last.netzwerk = netzwerk;
    last.wendigkeit = wendigkeit;
    last.antriebEffizienz = antriebEffizienz;
    last.energieSchild = energieSchild;
    last.energieSchildEffizienz = energieSchildEffizienz;
    last.zeitAmLeben = zeitAmLeben;
    last.zeitTod = zeitTod;
    last.schadenBekommen = schadenBekommen;
    last.schadenGemacht = schadenGemacht;
    last.treibstoffVerbraucht = treibstoffVerbraucht;
    last.schüsse = schüsse;
    last.treffer = treffer;
    last.punkte = punkte;
    last.kills = kills;
    last.tode = tode;
    last.level = level;
    for( auto s : *activeSkills )
        s->save();
}

void Spieler::load()
{
    setDrehungSpeed( last.rSpeed );
    setPosition( last.pos );
    setSpeed( last.speed );
    setDrehung( last.rotation );
    farbe = last.farbe;
    amLeben = last.amLeben;
    setCollision( amLeben );
    schussAbk = last.schussAbk;
    energieAbk = last.energieAbk;
    repAbk = last.repAbk;
    reinkAbk = last.reinkAbk;
    maxReinkAbk = last.maxReinkAbk;
    startPos = last.startPos;
    beschleunigung = last.beschleunigung;
    energie = last.energie;
    stabilität = last.stabilität;
    reparatur = last.reparatur;
    laserIntensität = last.laserIntensität;
    laserEffizienz = last.laserEffizienz;
    akkuLeistung = last.akkuLeistung;
    maxEnergie = last.maxEnergie;
    maxStabilität = last.maxStabilität;
    laserTempo = last.laserTempo;
    netzwerk = last.netzwerk;
    wendigkeit = last.wendigkeit;
    antriebEffizienz = last.antriebEffizienz;
    energieSchild = last.energieSchild;
    energieSchildEffizienz = last.energieSchildEffizienz;
    zeitAmLeben = last.zeitAmLeben;
    zeitTod = last.zeitTod;
    schadenBekommen = last.schadenBekommen;
    schadenGemacht = last.schadenGemacht;
    treibstoffVerbraucht = last.treibstoffVerbraucht;
    schüsse = last.schüsse;
    treffer = last.treffer;
    punkte = last.punkte;
    kills = last.kills;
    tode = last.tode;
    level = last.level;
    for( auto s : *activeSkills )
        s->load();
}

// constant
float Spieler::getEp() const
{
    return ep;
}

float Spieler::getMaxEp() const
{
    return nextSkillEp;
}

int Spieler::getAccountId() const
{
    return accountId;
}

Text* Spieler::getName() const
{
    return name ? dynamic_cast<Text*>(name->getThis()) : 0;
}

Text* Spieler::zName() const
{
    return name;
}

bool Spieler::hatSkill() const
{
    return skillPunkte != 0;
}

bool Spieler::istAmLeben() const
{
    return amLeben;
}

// Statistik Werte
int Spieler::getSpielerNummer() const
{
    return sNum;
}

Team* Spieler::zTeam() const
{
    return zteam;
}

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::getSchüsse() const
{
    return schüsse;
}

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

double Spieler::getTeamMaxEnergieBonus() const
{
    return maxEnergie / 100 * netzwerk;
}

double Spieler::getTeamMaxStabilitätBonus() const
{
    return maxStabilität / 100 * netzwerk;
}

double Spieler::getTeamReparaturBonus() const
{
    return reparatur / 100 * netzwerk;
}

double Spieler::getTeamLaserIntensitätBonus() const
{
    return laserIntensität / 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;
}

int Spieler::getSkillP() const
{
    return skillPunkte;
}

int Spieler::getLevel() const
{
    return level;
}