#include "Spieler.h"

#include "Team.h"
#include "Laser.h"
#include "Karte.h"
#include "SSKlient.h"
#include <iostream>

// Inhalt der Spieler Klasse aus Spieler.h
// Konstruktor
Spieler::Spieler( SpielerStr *zStr )
{
    accountId = 0;
    sNum = zStr->id;
    farbe = 0;
    ship = new Model2D();
    team = 0;
    klient = 0;
    for( int i = 0; i < T_MAX; i++ )
        tastatur[ i ] = 0;
    amLeben = 1;
    schussAbk = 0;
    energieAbk = 0;
    repAbk = 0;
    reinkAbk = 0;
    maxReinkAbk = 5;
    ref = 1;
    startPos = zStr->pos;
    pos = zStr->pos;
    speed = Vec2< double >( 0, 0 );
    rotation = zStr->rot;
    beschleunigung = zStr->beschleunigung;
    beschleunigungStart = zStr->beschleunigung;
    energie = zStr->maxEnergie;
    stability = zStr->maxStability;
    reparatur = zStr->reparatur;
    laserIntensity = zStr->laserIntensity;
    laserEffizienz = zStr->laserEffizienz;
    akkuLeistung = zStr->akkuLeistung;
    akkuLeistungStart = zStr->akkuLeistung;
    maxEnergie = zStr->maxEnergie;
    maxStability = zStr->maxStability;
    laserTempo = zStr->laserTempo;
    netzwerk = zStr->netzwerk;
    wendigkeit = zStr->wendigkeit;
    wendigkeitStart = zStr->wendigkeit;
    antriebEffizienz = zStr->antriebEffizienz;
    skillPunkte = zStr->skillPunkte;
    schadenBekommen = 0;
    schadenGemacht = 0;
    treibstoffVerbraucht = 0;
    shots = 0;
    treffer = 0;
    punkte = 0;
    kills = 0;
    tode = 0;
    zeitAmLeben = 0;
    zeitTod = 0;
    rSpeed = 0;
    ship->setPosition( pos );
    ship->setDrehung( (float)rotation );
}

// Destruktor
Spieler::~Spieler()
{
    ship->release();
    if( team )
        team->release();
    if( klient )
        klient->release();
}

// nicht constant
void Spieler::offline()
{
    klient->offline();
}

void Spieler::online( SSKlientV *zKlient )
{
    klient->online( zKlient );
}

void Spieler::setModelData( Model2DData *data )
{
    for( auto i = data->polygons->getArray(); i.set; i++ )
    {
        if( i.var.name->istGleich( "engine_l" ) )
        {
            stL = *i.var.schwerpunkt;
            Vertex l, r;
            for( int j = 0; j < 4; j++ )
            {
                if( i.var.tKordinaten->get( j ).y == 1.f )
                {
                    if( i.var.tKordinaten->get( j ).x == 0.f )
                        l = i.var.vertex->get( j );
                    if( i.var.tKordinaten->get( j ).x == 1.f )
                        r = i.var.vertex->get( j );
                }
            }
            kL = ( ( l + ( r - l ) * 0.5 ) - stL );
        }
        if( i.var.name->istGleich( "engine_r" ) )
        {
            stR = *i.var.schwerpunkt;
            Vertex l, r;
            for( int j = 0; j < 4; j++ )
            {
                if( i.var.tKordinaten->get( j ).y == 1.f )
                {
                    if( i.var.tKordinaten->get( j ).x == 0.f )
                        l = i.var.vertex->get( j );
                    if( i.var.tKordinaten->get( j ).x == 1.f )
                        r = i.var.vertex->get( j );
                }
            }
            kR = ( ( l + ( r - l ) * 0.5 ) - stR );
        }
        if( i.var.name->istGleich( "engine_m" ) )
        {
            stM = *i.var.schwerpunkt;
            Vertex l, r;
            for( int j = 0; j < 4; j++ )
            {
                if( i.var.tKordinaten->get( j ).y == 1.f )
                {
                    if( i.var.tKordinaten->get( j ).x == 0.f )
                        l = i.var.vertex->get( j );
                    if( i.var.tKordinaten->get( j ).x == 1.f )
                        r = i.var.vertex->get( j );
                }
            }
            kM = ( ( l + ( r - l ) * 0.5 ) - stM );
        }
    }
    kL.normalize();
    kR.normalize();
    kM.normalize();
    ship->setModel( data );
}

void Spieler::setAccountId( int id )
{
    accountId = id;
}

void Spieler::setTeam( Team *team )
{
    if( this->team )
        this->team->release();
    this->team = team;
}

void Spieler::setSpielerFarbe( int farbe )
{
    this->farbe = farbe;
}

void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
{
    speed = Vec2< double >( xSpeed, ySpeed );
}

void Spieler::setPosition( Vec2< double > p )
{
    pos = p;
    ship->setPosition( pos );
}

void Spieler::setKlient( Klient *klient )
{
    if( this->klient )
        this->klient->release();
    this->klient = klient;
}

bool Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
{
    if( tastatur[ ts ] == aktiv || !amLeben )
        return 0;
    tastatur[ ts ] = aktiv;
    return 1;
}

int Spieler::tick( double zeit, Karte *zMap )
{
    if( !team )
        return 0;
    reinkAbk -= zeit;
    if( reinkAbk < 0 )
        reinkAbk = 0;
    if( !reinkAbk && !amLeben )
    { // Wiederbelebung
        pos = startPos;
        reinkAbk = maxReinkAbk * 2;
        energie = maxEnergie + team->maxEnergie;
        stability = maxStability + team->maxStability;
        schussAbk = 0;
        energieAbk = 0;
        repAbk = 0;
        speed = Vec2< double >( 0, 0 );
        rotation = 0;
        rSpeed = 0;
        ship->setPosition( pos );
        ship->setDrehung( (float)rotation );
        for( int i = 0; i < T_MAX; i++ )
            tastatur[ i ] = 0;
        amLeben = 1;
        return 1;
    }
    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 ] )
        {
            Vertex hp;
            Vertex mv;
            float r;
            double treibstoff = 3 * ( ( beschleunigung + team->beschleunigung ) / 5 )
                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
            treibstoffVerbraucht += treibstoff;
            double factor = 1;
            if( treibstoff > energie )
                factor = energie / treibstoff;
            if( ship->zModel()->calcHitPoint( stM, kM * (float)( beschleunigung + team->beschleunigung ), ( char* )"ship", hp, mv, r ) )
            {
                speed += ( Vec2<double> )mv.rotation( (float)rotation ) * (float)zeit * factor;
            }
            energie -= treibstoff * factor;
        }
        double movementAngle = atan2( speed.y, speed.x );
        bool xg0 = speed.x > 0;
        bool yg0 = speed.y > 0;
        if( speed.x != 0 )
            speed.x += 5.0f * cos( movementAngle + PI ) * zeit;
        if( speed.y != 0 )
            speed.y += 5.0f * sin( movementAngle + PI ) * zeit;
        if( !xg0 && speed.x > 0 )
            speed.x = 0;
        if( !yg0 && speed.y > 0 )
            speed.y = 0;
        if( rSpeed > 0 )
        {
            rSpeed -= (float)( zeit * 0.5 );
            if( rSpeed < 0 )
                rSpeed = 0;
        }
        if( rSpeed < 0 )
        {
            rSpeed += (float)( zeit * 0.5 );
            if( rSpeed > 0 )
                rSpeed = 0;
        }
        if( tastatur[ T_ROT_R ] )
        {
            Vertex hp;
            Vertex mv;
            float r;
            double treibstoff = 1.5 * ( ( wendigkeit + team->wendigkeit ) / 5 )
                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
            treibstoffVerbraucht += treibstoff;
            double factor = 1;
            if( treibstoff > energie )
                factor = energie / treibstoff;
            if( ship->zModel()->calcHitPoint( stL, kL * (float)( wendigkeit + team->wendigkeit ), ( char* )"ship", hp, mv, r ) )
            {
                rSpeed += r * (float)zeit * (float)factor;
                speed += ( Vec2<double> )mv.rotation( (float)rotation ) * (float)zeit * factor;
            }
            energie -= treibstoff * factor;
        }
        if( tastatur[ T_ROT_L ] )
        {
            Vertex hp;
            Vertex mv;
            float r;
            double treibstoff = 1.5 * ( ( wendigkeit + team->wendigkeit ) / 5 )
                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
            treibstoffVerbraucht += treibstoff;
            double factor = 1;
            if( treibstoff > energie )
                factor = energie / treibstoff;
            if( ship->zModel()->calcHitPoint( stR, kR * (float)( wendigkeit + team->wendigkeit ), ( char* )"ship", hp, mv, r ) )
            {
                rSpeed += r * (float)zeit * (float)factor;
                speed += ( Vec2<double> )mv.rotation( (float)rotation ) * zeit * factor;
            }
            energie -= treibstoff * factor;
        }
        rotation += rSpeed * (float)zeit;
        ship->setDrehung( (float)rotation );
        if( speed.x || speed.y )
        {
            pos += speed * zeit;
            Vec2< int > gr = zMap->getSize();
            if( pos.x < 0 )
                pos.x += gr.x;
            if( pos.y < 0 )
                pos.y += gr.y;
            if( pos.x >= gr.x )
                pos.x -= gr.x;
            if( pos.y >= gr.y )
                pos.y -= gr.y;
            ship->setPosition( pos );
        }
        if( !energieAbk )
        {
            energie += ( akkuLeistung + team->akkuLeistung ) * zeit;
            if( energie > ( maxEnergie + team->maxEnergie ) )
                energie = ( maxEnergie + team->maxEnergie );
        }
        if( !repAbk )
        {
            stability += ( reparatur + team->reparatur ) * zeit;
            if( stability > ( maxStability + team->maxStability ) )
                stability = ( maxStability + team->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;
        team->maxStability = team->getMaxStabilityBonus();
        break;
    case 1: // Max Energie
        maxEnergie += 10;
        team->maxEnergie = team->getMaxEnergieBonus();
        break;
    case 2: // Reparatur
        reparatur += 0.15;
        team->reparatur = team->getReperaturBonus();
        break;
    case 3: // Laser Intensität
        laserIntensity += 3;
        team->laserIntensity = team->getLaserIntensityBonus();
        break;
    case 4: // Laser Effizienz
        laserEffizienz += 1;
        team->laserEffizienz = team->getLaserEffizienzBonus();
        break;
    case 5: // Laser Tempo
        laserTempo += 20;
        team->laserTempo = team->getLaserTempoBonus();
        break;
    case 6: // Beschleunigung
        beschleunigung += 1;
        team->beschleunigung = team->getBeschleunigungBonus();
        break;
    case 7: // Wendigkeit
        wendigkeit += 0.25;
        team->wendigkeit = team->getWendigkeitBonus();
        break;
    case 8: // Netzwerk
        netzwerk += 1;
        team->maxStability = team->getMaxStabilityBonus();
        team->maxEnergie = team->getMaxEnergieBonus();
        team->reparatur = team->getReperaturBonus();
        team->laserIntensity = team->getLaserIntensityBonus();
        team->laserEffizienz = team->getLaserEffizienzBonus();
        team->laserTempo = team->getLaserTempoBonus();
        team->beschleunigung = team->getBeschleunigungBonus();
        team->wendigkeit = team->getWendigkeitBonus();
        team->akkuLeistung = team->getAkkuLeistungBonus();
        team->antriebEffizienz = team->getAntriebEffizienzBonus();
        break;
    case 9: // Akkuleistung
        akkuLeistung += 0.12;
        team->akkuLeistung = team->getAkkuLeistungBonus();
        break;
    case 10: // Akkuleistung
        antriebEffizienz += 10;
        team->antriebEffizienz = team->getAntriebEffizienzBonus();
        break;
    }
    return 1;
}

Laser *Spieler::getLaser( int sId )
{
    if( !amLeben || !tastatur[ T_FEUER ] || schussAbk || !team )
        return 0;
    double kosten = ( ( laserIntensity + team->laserIntensity ) / 2 + ( laserTempo + team->laserTempo ) / 13 ) * ( 1 / ( ( laserEffizienz + team->laserEffizienz ) / 25 ) );
    if( kosten < 1 )
        kosten = 1;
    if( kosten > energie )
        return 0;
    energie -= kosten;
    schussAbk = 1;
    energieAbk = 1.5;
    shots++;
    Vec2< double > sSpeed = ( Vec2<double>( cos( rotation ), sin( rotation ) ) * ( laserTempo + team->laserTempo ) );
    sSpeed += speed;
    return new Laser( sId, pos, sSpeed, sNum, laserIntensity + team->laserIntensity );
}

bool Spieler::nimmSchaden( double intensity )
{
    std::cout << "Schaden: " << intensity << " ";
    stability -= intensity;
    std::cout << "Stabilität: " << stability << "\n";
    schadenBekommen += intensity;
    repAbk = 2;
    if( stability <= 0 )
    {
        amLeben = 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;
    }
}

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

bool Spieler::istOnline() const
{
    return klient ? klient->istOnline() : 0;
}

Klient *Spieler::zKlient() const
{
    return klient;
}

bool Spieler::istTreffer( Vec2< float > pos ) const
{
    if( !amLeben )
        return 0;
    return ship->istPunktInnen( pos );
}

// Raumschiff Eigenschaften
Vec2< double > Spieler::getPos() const
{
    return pos;
}

Vec2< double > Spieler::getSpeed() const
{
    return speed;
}

double Spieler::getRotation() const
{
    return rotation;
}

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

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

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

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

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

// Reference Counting
Spieler *Spieler::getThis()
{
    ref++;
    return this;
}

Spieler *Spieler::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}