#include "Spieler.h"
#include <Punkt.h>
#include <math.h>
#include <Rahmen.h>

// Inhalt der Spieler Klasse aus Spieler.h
// Konstruktor
Spieler::Spieler( KSGClient::InformationServerClient *zInfoK )
    : ReferenceCounter()
{
    xPos = 0;
    yPos = 0;
    xSpeed = 0;
    ySpeed = 0;
    kurve = 0;
    lKurve = 0;
    rKurve = 0;
    spielerNummer = 0;
    team = 0;
    radius = 1;
    teamRahmen = new LRahmen();
    teamRahmen->setRamenBreite( 1 );
    spielerFarbe = 0;
    teamFarbe = 0;
    info = dynamic_cast<KSGClient::InformationServerClient *>( zInfoK->getThis() );
    name = 0;
    accId = 0;
    amLeben = 1;
    linieUnterbrochen = 1;
}

// Destruktor
Spieler::~Spieler()
{
    teamRahmen->release();
    info->release();
    if( name )
        name->release();
}

// nicht constant
void Spieler::neuRunde()
{
    xPos = 0;
    yPos = 0;
    xSpeed = 0;
    ySpeed = 0;
    kurve = 0;
    lKurve = 0;
    rKurve = 0;
    radius = 1;
    amLeben = 1;
    linieUnterbrochen = 1;
}

void Spieler::setAccountId( int accId )
{
    this->accId = accId;
    name = info->getSpielerName( accId );
}

void Spieler::setSpielerNummer( int num )
{
    spielerNummer = num;
}

void Spieler::setTeam( int team )
{
    this->team = team;
}

void Spieler::setTeamFarbe( int fc )
{
    teamFarbe = fc;
}

void Spieler::setSpielerFarbe( int fc )
{
    spielerFarbe = fc;
}

void Spieler::setPos( double x, double y )
{
    xPos = x;
    yPos = y;
}

void Spieler::setRadius( int r )
{
    radius = r;
}

void Spieler::setSpeed( double xSpeed, double ySpeed )
{
    this->xSpeed = xSpeed;
    this->ySpeed = ySpeed;
}

void Spieler::setKurveSpeed( double kurve )
{
    this->kurve = kurve;
}

void Spieler::setLinksKurve( Bild *zMap, bool lKurve, double sendeZeit, double spielZeit )
{
    double sZ = -1;
    if( sendeZeit < spielZeit )
    {
        sZ = spielZeit;
        while( sendeZeit < spielZeit )
        {
            tick( zMap, -TICK );
            spielZeit -= TICK;
        }
    }
    this->lKurve = lKurve;
    if( sZ >= 0 )
    {
        while( spielZeit < sZ )
        {
            tick( zMap, TICK );
            spielZeit += TICK;
        }
    }
}

void Spieler::setRechtsKurve( Bild *zMap, bool rKurve, double sendeZeit, double spielZeit )
{
    double sZ = -1;
    if( sendeZeit < spielZeit )
    {
        sZ = spielZeit;
        while( sendeZeit < spielZeit )
        {
            tick( zMap, -TICK );
            spielZeit -= TICK;
        }
    }
    this->rKurve = rKurve;
    if( sZ >= 0 )
    {
        while( spielZeit < sZ )
        {
            tick( zMap, TICK );
            spielZeit += TICK;
        }
    }
}

void Spieler::sterben( Bild *zMap, double sendeZeit, double spielZeit )
{
    if( sendeZeit < spielZeit )
    {
        while( sendeZeit < spielZeit )
        {
            tick( zMap, -TICK );
            spielZeit -= TICK;
        }
    }
    amLeben = 0;
}

void Spieler::sterben()
{
    amLeben = 0;
}

void Spieler::setLinienUnterbrechung( Bild *zMap, bool unterbrechung, double sendeZeit, double spielZeit )
{
    double sZ = -1;
    if( sendeZeit < spielZeit )
    {
        sZ = spielZeit;
        while( sendeZeit < spielZeit )
        {
            tick( zMap, -TICK );
            spielZeit -= TICK;
        }
    }
    linieUnterbrochen = unterbrechung;
    if( sZ >= 0 )
    {
        while( spielZeit < sZ )
        {
            tick( zMap, TICK );
            spielZeit += TICK;
        }
    }
}

void Spieler::prozessKurve( double zeit )
{
    if( lKurve || rKurve )
    {
        double grad = kurve * zeit;
        if( lKurve )
            grad = -grad;
        double cs = cos( grad );
        double sn = sin( grad );
        double tmpX = ( xSpeed * cs - ySpeed * sn );
        double tmpY = ( xSpeed * sn + ySpeed * cs );
        xSpeed = tmpX;
        ySpeed = tmpY;
    }
}

void Spieler::tick( Bild *zMap, double zeit )
{
    if( amLeben )
    {
        if( zeit > 0 )
            prozessKurve( zeit );
        int dpx = 0;
        int dpy = 0;
        int dgx = zMap->getBreite();
        int dgy = zMap->getHeight();
        int *buff = zMap->getBuffer();
        if( zMap && !linieUnterbrochen )
        {
            int x1 = (int)( xPos + 0.5 );
            int y1 = (int)( yPos + 0.5 );
            int x2 = (int)( xPos + xSpeed * zeit + 0.5 );
            int y2 = (int)( yPos + ySpeed * zeit + 0.5 );
            int xlän = x2 - x1, axlän = abs( xlän );
            int ylän = y2 - y1, aylän = abs( ylän );
            double xf = (double)xlän / ( aylän ? aylän : 1 );
            double yf = (double)ylän / ( axlän ? axlän : 1 );
            if( axlän > aylän )
                xf = xf < 0 ? -1 : 1;
            else
                yf = yf < 0 ? -1 : 1;
            double x = (double)x1, y = (double)y1;
            int maxP = (int)( sqrt( (double)( xlän * xlän + ylän * ylän ) ) + 0.5 );
            int count = 0;
            int lastX = (int)( x + 0.5 ), lastY = (int)( y + 0.5 );
            if( zeit > 0 )
            {
                while( !( (int)( x + 0.5 ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
                {
                    if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
                    {
                        x += xf, y += yf;
                        lastX = (int)( x + 0.5 );
                        lastY = (int)( y + 0.5 );
                        count++;
                        continue;
                    }
                    buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
                    x += xf, y += yf;
                    if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
                    {
                        if( (int)xf )
                        {
                            if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
                                buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
                        }
                        else
                        {
                            if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
                                buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = spielerFarbe;
                        }
                    }
                    lastX = (int)( x + 0.5 );
                    lastY = (int)( y + 0.5 );
                    count++;
                }
            }
            if( zeit < 0 )
            {
                while( !( (int)( x ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
                {
                    count++;
                    x += xf, y += yf;
                    if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
                    {
                        if( (int)xf )
                        {
                            if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
                                buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = 0;
                        }
                        else
                        {
                            if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
                                buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
                        }
                    }
                    lastX = (int)( x + 0.5 );
                    lastY = (int)( y + 0.5 );
                    if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
                        buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = 0;
                }
            }
        }
        xPos += xSpeed * zeit;
        yPos += ySpeed * zeit;
        if( zeit < 0 )
            prozessKurve( zeit );
    }
}

void Spieler::render( Kamera *zKam, Bild &zRObj )
{
    if( amLeben )
    {
        if( zKam->istSichtbar( (int)xPos, (int)yPos ) )
        {
            teamRahmen->setFarbe( teamFarbe );
            teamRahmen->setSize( 5 * 2, 5 * 2 );
            teamRahmen->setPosition( zKam->getRX( (int)xPos ) - 5, zKam->getRY( (int)yPos ) - 5 );
            zRObj.fillRegion( teamRahmen->getX(), teamRahmen->getY(), 5 * 2, 5 * 2, spielerFarbe );
            teamRahmen->render( zRObj );
        }
    }
}

// constant
double Spieler::getX() const
{
    return xPos;
}

double Spieler::getY() const
{
    return yPos;
}

int Spieler::getTeam() const
{
    return team;
}

int Spieler::getTeamFarbe() const
{
    return teamFarbe;
}

int Spieler::getFarbe() const
{
    return spielerFarbe;
}

int Spieler::getSpielerNummer() const
{
    return spielerNummer;
}

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

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

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

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