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

// Inhalt der Spieler Klasse aus Spieler.h
// Konstruktor
Spieler::Spieler( InformationKlientV *zInfoK )
{
	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 = zInfoK->getThis();
	name = 0;
	accId = 0;
	amLeben = 1;
	linieUnterbrochen = 1;
	ref = 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 ? name->getThis() : 0;
}

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

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

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