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>

// Inhalt der Spieler Klasse aus Spieler.h
// Konstruktor
Spieler::Spieler( InformationKlientV *zInfoK, Schrift *zSchrift, SpielerStr *zStr )
{
	accountId = 0;
	sNum = zStr->id;
	farbe = 0;
	ship = new Model2D();
	ship->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur );
	team = 0;
	info = zInfoK->getThis();
	name = 0;
	for( int i = 0; i < T_MAX; i++ )
		tastatur[ i ] = 0;
	amLeben = 1;
	schussAbk = 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;
	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;
	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, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
						  TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
	spielZeit = 0;
	stopXSpeedT = -1;
	stopYSpeedT = -1;
	stopXSpeed = 0;
	stopYSpeed = 0;
	ship->setPosition( pos );
	ship->setDrehung( (float)rotation );
}

// Destruktor
Spieler::~Spieler()
{
    ship->release();
    info->release();
    if( team )
        team->release();
    if( name )
        name->release();
    flammenL->release();
    flammenR->release();
    flammenM->release();
}

double Spieler::calculateLaserCost()
{
    double kosten = ( laserIntensität + team->laserIntensität + ( laserTempo + team->laserTempo ) / 5 ) - ( laserEffizienz + team->laserEffizienz );
    if( kosten < 1 )
        kosten = 1;
    return kosten;
}

// nicht constant
void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn )
{
	ship->setModel( data );
    flammenM = new Textur2D();
    flammenM->addAnimationZ( zFStart->getThis() );
    flammenM->addAnimationZ( zFBurn->getThis() );
    flammenL = new Textur2D();
    flammenL->addAnimationZ( zFStart->getThis() );
    flammenL->addAnimationZ( zFBurn->getThis() );
    flammenR = new Textur2D();
    flammenR->addAnimationZ( zFStart->getThis() );
    flammenR->addAnimationZ( zFBurn->getThis() );
    ship->setTextur( flammenL->getThis(), "engine_l" );
    ship->setTextur( flammenR->getThis(), "engine_r" );
    ship->setTextur( flammenM->getThis(), "engine_m" );
}

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

void Spieler::setTeam( Team *team )
{
	if( this->team )
		this->team->release();
	this->team = team;
	nText->setHintergrundFarbe( 0xA0000000 | ( team->farbe & 0x00FFFFFF ) );
	nText->setLinienRahmenFarbe( team->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, ( buffer[ i ] & 0xFF000000 ) | ( fc & 0x00FFFFFF ) );
			shb->alphaPixelDP( i, buffer[ i ] );
		}
	}
    Textur2D *textur = new Textur2D();
    textur->setTexturZ( shb );
	ship->setTextur( textur, "ship" );
}

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::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap )
{
	if( !amLeben )
	{
		tastatur[ ts ] = aktiv;
		return;
	}
	int z = sZ - spielZeit;
	setMoveZeit( z, zMap );
	tastatur[ ts ] = aktiv;
	setMoveZeit( -z, zMap );
    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 );
        case T_ROT_R:
            if( aktiv )
                flammenL->setAnimation( 0 );
            else
                flammenL->setAnimation( -1 );
        }
    }
}

bool Spieler::tick( Karte *zMap )
{
	if( !team )
		return 0;
	bool ret = 0;
	double tv = TICK;
	reinkAbk -= tv;
	if( reinkAbk < 0 )
		reinkAbk = 0;
    flammenM->tick( tv );
    flammenL->tick( tv );
    flammenR->tick( tv );
	if( !reinkAbk && !amLeben )
	{ // Wiederbelebung
		//wiederbelebung( spielZeit );
	}
	if( amLeben )
	{
		schussAbk -= tv;
		if( schussAbk < 0 )
			schussAbk = 0;
		repAbk -= tv;
		if( repAbk < 0 )
			repAbk = 0;
		setMoveZeit( 1, zMap );
		if( !schussAbk )
		{
			if( energie != ( maxEnergie + team->maxEnergie ) )
				ret = 1;
			energie += ( akkuLeistung + team->akkuLeistung ) * tv;
			if( energie >( maxEnergie + team->maxEnergie ) )
				energie = ( maxEnergie + team->maxEnergie );
		}
		if( !repAbk )
		{
			if( stabilität != ( maxStabilität + team->maxStabilität ) )
				ret = 1;
			stabilität += ( reparatur + team->reparatur ) * tv;
			if( stabilität > ( maxStabilität + team->maxStabilität ) )
				stabilität = ( maxStabilität + team->maxStabilität );
		}
		zeitAmLeben += tv;
	}
	else
	{
		zeitTod += tv;
		spielZeit++;
	}
	return ret;
}

void Spieler::render( Bild &zRObj )
{
	if( !amLeben )
		return;
	ship->render( zRObj );
}

void Spieler::renderLeben( Bild &zRObj )
{
	if( !team || !amLeben )
		return;
	nText->setPosition( ship->getPosition() - Punkt( 76, (int)( ship->zModel()->maxP.y * ship->getSize() ) + 30 ) );
	nText->render( zRObj );
	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, team->farbe );
	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, team->farbe );
	int l = (int)( stabilität * 100 / ( maxStabilität + team->maxStabilitä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 / ( maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFFFFFF00 );
	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFFFFFF00 );
	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFFFFFF00 );
    int e2 = (int)( (energie - calculateLaserCost() ) * 100 / ( maxEnergie + team->maxEnergie ) * 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::renderMinimap( Bild &zRObj, Karte *zMap )
{
	if( !team || !amLeben )
		return;
	int x = (int)( ( pos.x / zMap->getSize().x ) * 250 + 0.5 ) - 2;
	int y = (int)( ( pos.y / zMap->getSize().y ) * 250 + 0.5 ) - 2;
	zRObj.fillRegion( x, y, 4, 4, team->farbe );
	zRObj.fillRegion( x + 1, y + 1, 2, 2, farbe );
}

void Spieler::setSkill( int art )
{
	skillPunkte--;
	switch( art )
	{
	case 0: // Max Stabilität
		maxStabilität += 10;
		team->maxStabilität = team->getMaxStabilitätBonus();
		break;
	case 1: // Max Energie
		maxEnergie += 10;
		team->maxEnergie = team->getMaxEnergieBonus();
		break;
	case 2: // Reparatur
		reparatur += 0.1;
		team->reparatur = team->getReperaturBonus();
		break;
	case 3: // Laser Intensität
		laserIntensität += 3;
		team->laserIntensität = team->getLaserIntensitätBonus();
		break;
	case 4: // Laser Effizienz
		laserEffizienz += 2;
		team->laserEffizienz = team->getLaserEffizienzBonus();
		break;
	case 5: // Laser Tempo
		laserTempo += 10;
		team->laserTempo = team->getLaserTempoBonus();
		break;
	case 6: // Beschleunigung
		beschleunigung += 2;
		team->beschleunigung = team->getBeschleunigungBonus();
		break;
	case 7: // Wendigkeit
		wendigkeit += 0.15;
		team->wendigkeit = team->getWendigkeitBonus();
		break;
	case 8: // Netzwerk
		netzwerk += 1;
		team->maxStabilität = team->getMaxStabilitätBonus();
		team->maxEnergie = team->getMaxEnergieBonus();
		team->reparatur = team->getReperaturBonus();
		team->laserIntensität = team->getLaserIntensitätBonus();
		team->laserEffizienz = team->getLaserEffizienzBonus();
		team->laserTempo = team->getLaserTempoBonus();
		team->beschleunigung = team->getBeschleunigungBonus();
		team->wendigkeit = team->getWendigkeitBonus();
		team->akkuLeistung = team->getAkkuLeistungBonus();
		break;
	case 9: // Akkuleistung
		akkuLeistung += 0.4;
		team->akkuLeistung = team->getAkkuLeistungBonus();
		break;
	}
}

void Spieler::nimmSchaden( double intensität )
{
	stabilität -= intensität;
	schadenBekommen += intensität;
	repAbk = 2;
}

void Spieler::machSchaden( double intensität )
{
	schadenGemacht += intensität;
	treffer++;
}

void Spieler::addKill()
{
	kills++;
	punkte++;
	skillPunkte += 2;
	maxReinkAbk--;
	if( maxReinkAbk < 5 )
		maxReinkAbk = 5;
}

void Spieler::sterben()
{
	amLeben = 0;
	tode++;
	stabilität = 0;
	reinkAbk += maxReinkAbk;
	maxReinkAbk++;
	punkte--;
}

void Spieler::wiederbelebung()
{
	pos = startPos;
	reinkAbk = maxReinkAbk * 2;
	energie = maxEnergie + team->maxEnergie;
	stabilität = maxStabilität + team->maxStabilität;
	schussAbk = 0;
	repAbk = 0;
	speed = Vec2< double >( 0, 0 );
	rotation = 0;
	ship->setDrehung( (float)rotation );
	ship->setPosition( pos );
	for( int i = 0; i < T_MAX; i++ )
		tastatur[ i ] = 0;
    flammenM->setAnimation( -1 );
    flammenL->setAnimation( -1 );
    flammenR->setAnimation( -1 );
	amLeben = 1;
}

void Spieler::setMoveZeit( int z, Karte *zMap )
{
	spielZeit += z;
	double tv = TICK * z;
	if( tv < 0 )
	{
		if( speed.x || speed.y )
			pos += speed * tv;
		Vec2< int > gr = zMap->getSize();
		while( pos.x < 0 )
			pos.x += gr.x;
		while( pos.y < 0 )
			pos.y += gr.y;
		while( pos.x >= gr.x )
			pos.x -= gr.x;
		while( pos.y >= gr.y )
			pos.y -= gr.y;
		ship->setPosition( pos );
		if( tastatur[ T_ROT_R ] )
			rotation += tv * ( wendigkeit + team->wendigkeit );
		if( tastatur[ T_ROT_L ] )
			rotation -= tv * ( wendigkeit + team->wendigkeit );
		ship->setDrehung( (float)rotation );
		if( tastatur[ T_GAS ] )
		{
			treibstoffVerbraucht += tv;
			speed.x += ( beschleunigung + team->beschleunigung ) * cos( rotation ) * tv;
			speed.y += ( beschleunigung + team->beschleunigung ) * sin( rotation ) * tv;
		}
		else
		{
			double movementAngle = atan2( speed.y, speed.x );
			for( int i = 1; i <= -z; i++ )
			{
				if( stopXSpeedT == spielZeit + ( -z - i ) )
					speed.x = stopXSpeed;
				if( stopYSpeedT == spielZeit + ( -z - i ) )
					speed.y = stopYSpeed;
				if( speed.x != 0 )
					speed.x += 30.0f * cos( movementAngle + PI ) * -TICK;
				if( speed.y != 0 )
					speed.y += 30.0f * sin( movementAngle + PI ) * -TICK;
			}
		}
	}
	else
	{
		if( tastatur[ T_GAS ] )
		{
			treibstoffVerbraucht += tv;
			speed.x += ( beschleunigung + team->beschleunigung ) * cos( rotation ) * tv;
			speed.y += ( beschleunigung + team->beschleunigung ) * sin( rotation ) * tv;
		}
		else
		{
			double movementAngle = atan2( speed.y, speed.x );
			for( int i = 1; i <= z; i++ )
			{
				if( speed.x != 0 )
					speed.x += 30.0f * cos( movementAngle + PI ) * TICK;
				if( speed.y != 0 )
					speed.y += 30.0f * sin( movementAngle + PI ) * TICK;
				if( speed.x < 6.f && speed.x > -6.f )
				{
					stopXSpeedT = spielZeit - ( z - i );
					stopXSpeed = speed.x;
					speed.x = 0;
				}
				if( speed.y < 6.f && speed.y > -6.f )
				{
					stopYSpeedT = spielZeit - ( z - i );
					stopYSpeed = speed.y;
					speed.y = 0;
				}
			}
		}
		if( tastatur[ T_ROT_R ] )
			rotation += tv * ( wendigkeit + team->wendigkeit );
		if( tastatur[ T_ROT_L ] )
			rotation -= tv * ( wendigkeit + team->wendigkeit );
		ship->setDrehung( (float)rotation );
		if( speed.x || speed.y )
			pos += speed * tv;
		Vec2< int > gr = zMap->getSize();
		while( pos.x < 0 )
			pos.x += gr.x;
		while( pos.y < 0 )
			pos.y += gr.y;
		while( pos.x >= gr.x )
			pos.x -= gr.x;
		while( pos.y >= gr.y )
			pos.y -= gr.y;
		ship->setPosition( pos );
	}
}

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

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

Text *Spieler::getName() const
{
	return name ? 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 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::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;
}

Punkt Spieler::getPos() const
{
	return (Punkt)pos;
}

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

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

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