Linie-Online-Client/Linie/Aufzeichnung/Spieler/VideoSpieler.cpp

#include "VideoSpieler.h"
#include <Punkt.h>
#include <math.h>
#include <Rahmen.h>
#include <InitDatei.h>

// Inhalt der VideoSpieler Klasse aus VideoSpieler.h
// Konstruktor
VideoSpieler::VideoSpieler( SpielerVideoDaten *vDaten )
    : ReferenceCounter()
{
    spielerNummer = vDaten->spielerNummer;
    team = vDaten->team;
    spielerFarbe = 0;
    teamFarbe = 0;
    daten = new Array< VideoSpielerRundeDaten * >();
    daten->set( new VideoSpielerRundeDaten( { 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 } ), 0 );
    runde = -1;
    name = new Text();
    teamName = new Text();
    teamRahmen = new LRahmen();
    teamRahmen->setRamenBreite( 1 );
    teamRahmen->setSize( 10, 10 );
    spielerFarbe = vDaten->spielerFarbe;
    teamFarbe = vDaten->teamFarbe;
    name->setText( vDaten->name.getText() );
    teamName->setText( vDaten->teamName.getText() );
    teamRahmen->setFarbe( vDaten->teamFarbe );
    gewonneneRunden = 0;
    linienLänge = 0;
    zeitAmLeben = 0;
    zeitTod = 0;
    kills = 0;
    tode = 0;
    killFarbe = 0;
}

// Destruktor
VideoSpieler::~VideoSpieler()
{
    teamRahmen->release();
    name->release();
    teamName->release();
    int anz = daten->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        if( daten->hat( i ) )
            delete daten->get( i );
    }
    daten->release();
}

// nicht constant
void VideoSpieler::addKill()
{
    kills++;
    rKills.set( rKills.get( runde ) + 1, runde );
}

void VideoSpieler::neuRunde( bool vorwärts, RundeSpielerVideoDaten *vDaten, bool amLeben )
{
    if( vorwärts )
    {
        if( runde >= 0 )
        {
            if( daten->get( runde )->amLeben )
                gewonneneRunden++;
        }
        runde++;
        rLinienLänge.set( 0, runde );
        rKills.set( 0, runde );
        rTodesZeit.set( 0, runde );
        if( daten->hat( runde ) )
            delete daten->get( runde );
        daten->set( new VideoSpielerRundeDaten( { vDaten->xPos, vDaten->yPos, vDaten->xSpeed,
                                                  vDaten->ySpeed, vDaten->wendigkeit, 1, amLeben, 0, 0, 1, 0, 0 } ), runde );
    }
    else
        runde--;
}

void VideoSpieler::setLinksKurve( bool lKurve )
{
    daten->get( runde )->lKurve = lKurve;
}

void VideoSpieler::setRechtsKurve( bool rKurve )
{
    daten->get( runde )->rKurve = rKurve;
}

void VideoSpieler::setLinienUnterbrechung( bool unterbrechung )
{
    daten->get( runde )->linieUnterbrochen = unterbrechung;
}

void VideoSpieler::prozessKurve( double zeit )
{
    VideoSpielerRundeDaten *dat = daten->get( runde );
    if( dat->amLeben )
    {
        if( dat->lKurve || dat->rKurve )
        {
            double grad = dat->kurve * zeit;
            if( dat->lKurve )
                grad = -grad;
            double cs = cos( grad );
            double sn = sin( grad );
            double tmpX = ( dat->xSpeed * cs - dat->ySpeed * sn );
            double tmpY = ( dat->xSpeed * sn + dat->ySpeed * cs );
            dat->xSpeed = tmpX;
            dat->ySpeed = tmpY;
        }
    }
}

void VideoSpieler::tick( Bild *zMap, double zeit )
{
    VideoSpielerRundeDaten *dat = daten->get( runde );
    dat->spielZeit += zeit;
    bool wiederbelebt = 0;
    bool rückwärts = zeit < 0;
    if( rückwärts && !dat->amLeben )
    {
        if( dat->todesZeit >= dat->spielZeit )
        {
            dat->amLeben = 1;
            wiederbelebt = 1;
        }
    }
    if( dat->amLeben )
    {
        zeitAmLeben += zeit;
        if( !rückwärts )
            prozessKurve( zeit );
        int dpx = 0;
        int dpy = 0;
        int dgx = zMap->getBreite();
        int dgy = zMap->getHeight();
        int *buff = zMap->getBuffer();
        if( zMap && !dat->linieUnterbrochen )
        {
            int x1 = (int)( dat->xPos + 0.5 );
            int y1 = (int)( dat->yPos + 0.5 );
            int x2 = (int)( dat->xPos + dat->xSpeed * zeit + 0.5 );
            int y2 = (int)( dat->yPos + dat->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( !rückwärts )
            {
                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 )
                    {
                        killFarbe = 0;
                        tode++;
                        dat->todesZeit = dat->spielZeit;
                        rTodesZeit.set( (int)dat->spielZeit, runde );
                        dat->amLeben = 0;
                        dat->renderVorTod = count;
                        break;
                    }
                    if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] )
                    {
                        if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] != spielerFarbe )
                            killFarbe = buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ];
                        else
                            killFarbe = 0;
                        tode++;
                        dat->todesZeit = dat->spielZeit;
                        rTodesZeit.set( (int)dat->spielZeit, runde );
                        dat->amLeben = 0;
                        dat->renderVorTod = count;
                        break;
                    }
                    buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
                    linienLänge++;
                    rLinienLänge.set( rLinienLänge.get( runde ) + 1, runde );
                    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( rückwärts )
            {
                if( wiederbelebt )
                    maxP = dat->renderVorTod;
                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;
                }
            }
        }
        dat->xPos += dat->xSpeed * zeit;
        dat->yPos += dat->ySpeed * zeit;
        if( rückwärts )
            prozessKurve( zeit );
    }
    else
        zeitTod += zeit;
}

void VideoSpieler::render( VideoKamera *zKam, Bild &zRObj )
{
    VideoSpielerRundeDaten *dat = daten->get( runde );
    if( dat->amLeben )
    {
        if( zKam->istSichtbar( (int)dat->xPos, (int)dat->yPos ) )
        {
            teamRahmen->setPosition( zKam->getRX( (int)dat->xPos ) - 5, zKam->getRY( (int)dat->yPos ) - 5 );
            zRObj.fillRegion( teamRahmen->getX(), teamRahmen->getY(), 10, 10, spielerFarbe );
            teamRahmen->render( zRObj );
        }
    }
}

// constant
double VideoSpieler::getX() const
{
    return daten->get( runde )->xPos;
}

double VideoSpieler::getY() const
{
    return daten->get( runde )->yPos;
}

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

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

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

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

bool VideoSpieler::istAmLeben() const
{
    return daten->get( runde )->amLeben;
}

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

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

Text *VideoSpieler::getTeamName() const
{
    return teamName ? dynamic_cast<Text *>( teamName->getThis() ) : 0;
}

Text *VideoSpieler::zTeamName() const
{
    return teamName;
}

bool VideoSpieler::istMausIn( int mx, int my ) const
{
    VideoSpielerRundeDaten *dat = daten->get( runde );
    return mx >= (int)dat->xPos - 5 && mx <= (int)dat->xPos + 5 &&
        my >= (int)dat->yPos - 5 && my <= (int)dat->yPos + 5;
}

int VideoSpieler::getGewonneneRunden() const
{
    return gewonneneRunden;
}

int VideoSpieler::getLinienLänge() const
{
    return linienLänge;
}

int VideoSpieler::getZeitAmLeben() const
{
    return (int)zeitAmLeben;
}

int VideoSpieler::getZeitTod() const
{
    return (int)zeitTod;
}

int VideoSpieler::getKills() const
{
    return kills;
}

int VideoSpieler::getTode() const
{
    return tode;
}

int VideoSpieler::getKillFarbe() const
{
    return killFarbe;
}

int VideoSpieler::getLinienLänge( int r ) const
{
    return rLinienLänge.get( r );
}

int VideoSpieler::getKills( int r ) const
{
    return rKills.get( r );
}

int VideoSpieler::getTodesZeit( int r ) const
{
    return rTodesZeit.get( r );
}