Linie-Online-Client/Linie/Aufzeichnung/Nachricht/VideoNachricht.cpp

#include "VideoNachricht.h"

// Inhalt der RundeNachricht Klasse aus VideoNachricht.h
// Konstruktor
RundeNachricht::RundeNachricht( Datei *d, int spielerAnzahl )
    : ReferenceCounter()
{
    index = 0;
    maxNachricht = 0;
    nachrichten = new Array< VideoMSG * >();
    vDat = d;
    rvd = new RundeVideoDaten();
    rsvd = new Array< RundeSpielerVideoDaten * >();
    aktiv = 1;
    vDat->lese( (char *)&rvd->mapBreite, 4 );
    vDat->lese( (char *)&rvd->mapHöhe, 4 );
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        RundeSpielerVideoDaten *svd = new RundeSpielerVideoDaten();
        vDat->lese( (char *)&svd->wendigkeit, 8 );
        vDat->lese( (char *)&svd->xPos, 8 );
        vDat->lese( (char *)&svd->yPos, 8 );
        vDat->lese( (char *)&svd->xSpeed, 8 );
        vDat->lese( (char *)&svd->ySpeed, 8 );
        rsvd->set( svd, i );
    }
}

// Destruktor
RundeNachricht::~RundeNachricht()
{
    for( int i = 0; i < maxNachricht; i++ )
    {
        VideoMSG *tmp = nachrichten->get( i );
        if( !tmp->typ )
            delete (VideoMSG *)tmp;
        else
        {
            if( ( (VideoAktionMSG *)tmp )->aktion == 4 )
                delete (VideoChatMSG *)tmp;
            else if( ( (VideoAktionMSG *)tmp )->aktion == 5 )
                delete (VideoLinieMSG *)tmp;
            else
                delete (VideoAktionMSG *)tmp;
        }
    }
    nachrichten->release();
    vDat->release();
    delete rvd;
    int anz = rsvd->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        delete rsvd->get( i );
    rsvd->release();
}

// nicht constant
VideoMSG *RundeNachricht::GetNextNachricht()
{
    if( index < maxNachricht )
    {
        index++;
        return nachrichten->get( index - 1 );
    }
    else if( aktiv )
    {
        char typ = 0;
        vDat->lese( &typ, 1 );
        if( !typ )
        {
            VideoMSG *vtmsg = new VideoMSG();
            vtmsg->typ = typ;
            nachrichten->set( vtmsg, index );
            index++;
            maxNachricht++;
            return vtmsg;
        }
        else if( typ == 1 )
        {
            NachrichtVideoDaten nvd;
            vDat->lese( (char *)&nvd.spielerNummer, 4 );
            vDat->lese( (char *)&nvd.län, 2 );
            char *bytes = new char[ nvd.län ];
            vDat->lese( bytes, nvd.län );
            if( bytes[ 0 ] >= 0 && bytes[ 0 ] <= 3 )
            {
                VideoAktionMSG *vamsg = new VideoAktionMSG();
                vamsg->typ = typ;
                vamsg->spielerNummer = nvd.spielerNummer;
                vamsg->aktion = bytes[ 0 ];
                nachrichten->set( vamsg, index );
                index++;
                maxNachricht++;
                delete[] bytes;
                return vamsg;
            }
            if( bytes[ 0 ] == 4 )
            {
                VideoChatMSG *vcmsg = new VideoChatMSG();
                vcmsg->typ = typ;
                vcmsg->spielerNummer = nvd.spielerNummer;
                vcmsg->aktion = bytes[ 0 ];
                vcmsg->län = nvd.län - 1;
                vcmsg->msg.setText( bytes + 1, vcmsg->län );
                nachrichten->set( vcmsg, index );
                index++;
                maxNachricht++;
                delete[] bytes;
                return vcmsg;
            }
            if( bytes[ 0 ] == 5 )
            {
                VideoLinieMSG *vlmsg = new VideoLinieMSG();
                vlmsg->typ = typ;
                vlmsg->spielerNummer = nvd.spielerNummer;
                vlmsg->aktion = bytes[ 0 ];
                vlmsg->unterbrechung = *( bytes + 1 );
                nachrichten->set( vlmsg, index );
                index++;
                maxNachricht++;
                delete[] bytes;
                return vlmsg;
            }
            delete[] bytes;
        }
        else
        {
            VideoMSG *msg = new VideoMSG();
            msg->typ = typ;
            nachrichten->set( msg, index );
            index++;
            maxNachricht++;
            return msg;
        }
    }
    return 0;
}

VideoMSG *RundeNachricht::GetLastNachricht()
{
    if( index == 0 )
        return 0;
    index--;
    return nachrichten->get( index );
}

void RundeNachricht::setEnde()
{
    aktiv = 0;
}

// constant
RundeVideoDaten *RundeNachricht::getRVD() const
{
    return rvd;
}

RundeSpielerVideoDaten *RundeNachricht::getRSVD( int index ) const
{
    if( !rsvd->hat( index ) )
        return 0;
    return rsvd->get( index );
}


// Inhalt der SpielNachricht Klasse aus VideoNachricht.h
// Konatruktor
SpielNachricht::SpielNachricht( int num )
    : ReferenceCounter()
{
    runde = 0;
    maxRunde = 0;
    teamAnzahl = 0;
    runden = new RCArray< RundeNachricht >();
    vDat = new Datei();
    svd = new SpielVideoDaten();
    spvd = new Array< SpielerVideoDaten * >();
    tvd = new Array< TeamVideoDaten * >();
    error = 0;
    fehler = new Text();
    Text pfad( "data/tmp/historie/" );
    pfad += num;
    pfad += "/verlauf.ksggl";
    vDat->setDatei( pfad );
    if( !vDat->open( Datei::Style::lesen ) )
    {
        *fehler = "Die Videodatei '";
        *fehler += pfad;
        *fehler += "' konnte nicht geöffnet werden.\nEs existiert eventuell keine Aufzeichnung von diesem Spiel.";
        error = 1;
    }
    Array< int > team;
    if( !error )
    {
        vDat->lese( (char *)&svd->spielerAnzahl, 4 );
        for( int i = 0; i < svd->spielerAnzahl; i++ )
        {
            SpielerVideoDaten *svd = new SpielerVideoDaten();
            vDat->lese( (char *)&svd->index, 4 );
            vDat->lese( (char *)&svd->spielerNummer, 4 );
            vDat->lese( (char *)&svd->kamBreite, 4 );
            vDat->lese( (char *)&svd->kamHöhe, 4 );
            vDat->lese( (char *)&svd->team, 4 );
            vDat->lese( (char *)&svd->spielerFarbe, 4 );
            vDat->lese( (char *)&svd->teamFarbe, 4 );
            char län = 0;
            vDat->lese( &län, 1 );
            char *n = new char[ län + 1 ];
            n[ län ] = 0;
            if( län )
                vDat->lese( n, län );
            svd->name.setText( n );
            delete[] n;
            vDat->lese( &län, 1 );
            n = new char[ län + 1 ];
            n[ län ] = 0;
            if( län )
                vDat->lese( n, län );
            svd->teamName.setText( n );
            delete[] n;
            spvd->set( svd, svd->index );
            if( team.getWertIndex( svd->team ) < 0 )
            {
                team.set( svd->team, teamAnzahl );
                teamAnzahl++;
            }
        }
        for( int i = 0; i < teamAnzahl; i++ )
        {
            TeamVideoDaten *t = new TeamVideoDaten();
            vDat->lese( (char *)&t->teamNummer, 4 );
            vDat->lese( (char *)&t->maxPunkte, 4 );
            vDat->lese( (char *)&t->punkte, 4 );
            tvd->set( t, i );
        }
        RundeNachricht *r = new RundeNachricht( dynamic_cast<Datei *>( vDat->getThis() ), svd->spielerAnzahl );
        runden->set( r, runde );
    }
}

// Destruktor
SpielNachricht::~SpielNachricht()
{
    runden->release();
    vDat->close();
    vDat->release();
    for( int i = 0; i < svd->spielerAnzahl; i++ )
        delete spvd->get( i );
    delete svd;
    spvd->release();
    for( int i = 0; i < teamAnzahl; i++ )
        delete tvd->get( i );
    tvd->release();
    fehler->release();
}

// nicht constant
VideoMSG *SpielNachricht::GetNextNachricht()
{
    return runden->z( runde )->GetNextNachricht();
}

VideoMSG *SpielNachricht::GetLastNachricht()
{
    return runden->z( runde )->GetLastNachricht();
}

int SpielNachricht::setRundenEnde( bool vorwärts )
{
    if( vorwärts )
    {
        if( runde < maxRunde )
            runde++;
        else
        {
            runden->z( runde )->setEnde();
            runde++;
            maxRunde++;
            RundeNachricht *tmp = new RundeNachricht( dynamic_cast<Datei *>( vDat->getThis() ), svd->spielerAnzahl );
            runden->set( tmp, runde );
        }
    }
    else
        runde--;
    if( runde < 0 )
    {
        runde = 0;
        return -1;
    }
    return runde;
}

// constant
SpielVideoDaten *SpielNachricht::getSVD() const
{
    return svd;
}

SpielerVideoDaten *SpielNachricht::getSPVD( int index ) const
{
    if( !spvd->hat( index ) )
        return 0;
    return spvd->get( index );
}

TeamVideoDaten *SpielNachricht::getTVD( int index ) const
{
    if( !tvd->hat( index ) )
        return 0;
    return tvd->get( index );
}

RundeVideoDaten *SpielNachricht::getRVD() const
{
    return runden->z( runde )->getRVD();
}

RundeSpielerVideoDaten *SpielNachricht::getRSVD( int index ) const
{
    return runden->z( runde )->getRSVD( index );
}

bool SpielNachricht::hatFehler( Text *txt ) const
{
    txt->setText( fehler->getText() );
    return error;
}

int SpielNachricht::getTeamAnzahl() const
{
    return teamAnzahl;
}

int SpielNachricht::getRunde() const
{
    return runde;
}