Linie-Online-Client/Linie/Aufzeichnung/Bestenliste/VideoBestenliste.cpp

#include "VideoBestenliste.h"
#include "..\Spieler\VideoSpieler.h"
#include <Rahmen.h>
#include <Schrift.h>
#include <Punkt.h>
#include <Scroll.h>
#include <Bild.h>
#include <Text.h>

// Inhalt der VideoBLSpieler Klasse aus VideoBestenliste.h
// Konstruktor
VideoBLSpieler::VideoBLSpieler( int sNum, int farbe, UIInit &uiFactory )
    : ReferenceCounter()
{
    this->sNum = sNum;
    this->farbe = farbe;
    p = 0;
    nP = 0;

    rahmen = new LRahmen();
    rahmen->setFarbe( farbe );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 400, 20 );

    name = uiFactory.createTextFeld( uiFactory.initParam );
    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    name->setSchriftFarbe( farbe );
    name->setSize( 100, 20 );
    name->setPosition( 0, 0 );
    name->setText( "" );

    punkte = uiFactory.createTextFeld( uiFactory.initParam );
    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    punkte->setSchriftFarbe( farbe );
    punkte->setSize( 100, 20 );
    punkte->setPosition( 100, 0 );
    punkte->setText( "" );

    neuPunkte = uiFactory.createTextFeld( uiFactory.initParam );
    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    neuPunkte->setSchriftFarbe( farbe );
    neuPunkte->setSize( 100, 20 );
    neuPunkte->setPosition( 200, 0 );
    neuPunkte->setText( "" );

    status = uiFactory.createTextFeld( uiFactory.initParam );
    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    status->setSchriftFarbe( 0xFF00FF00 );
    status->setSize( 100, 20 );
    status->setPosition( 300, 0 );
    status->setText( "lebt" );

    rundenNP = new Array< int >();
    runde = 0;
}

// Destruktor
VideoBLSpieler::~VideoBLSpieler()
{
    rahmen->release();
    name->release();
    punkte->release();
    neuPunkte->release();
    status->release();
    rundenNP->release();
}

// nicht constant
bool VideoBLSpieler::updateStatus( VideoSpieler *zSpieler )
{
    if( sNum != zSpieler->getSpielerNummer() )
        return 0;
    if( zSpieler->istAmLeben() )
    {
        status->setSchriftFarbe( 0xFF00FF00 );
        status->setText( "lebt" );
    }
    else
    {
        status->setSchriftFarbe( 0xFFFF0000 );
        status->setText( "tot" );
    }
    name->setText( zSpieler->zName()->getText() );
    return 1;
}

void VideoBLSpieler::setPunkte( int p )
{
    this->p = p;
}

void VideoBLSpieler::addPunkt( bool plus )
{
    if( plus )
        nP++;
    else
        nP--;
}

void VideoBLSpieler::updatePunkte( bool vorwärts )
{
    if( vorwärts )
    {
        p += nP;
        rundenNP->set( nP, runde );
        nP = 0;
        runde++;
    }
    else
    {
        runde--;
        nP = rundenNP->get( runde );
        p -= nP;
    }
}

void VideoBLSpieler::render( int y, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
        return;
    punkte->setText( "" );
    if( nP == 0 )
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
    }
    else if( nP > 0 )
    {
        neuPunkte->setText( "+" );
        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
    }
    else
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
    }
    punkte->zText()->append( p > 0 ? p : 0 );
    neuPunkte->zText()->append( nP );
    rahmen->render( zRObj );
    name->render( zRObj );
    punkte->render( zRObj );
    neuPunkte->render( zRObj );
    status->render( zRObj );
    zRObj.releaseDrawOptions();
}

// constant
int VideoBLSpieler::getSpielerNummer() const
{
    return sNum;
}

int VideoBLSpieler::getPunkte() const
{
    return p + nP;
}

// Inhalt der VideoBLTeam Klasse aus VideoBestenliste.h
// Konstruktor
VideoBLTeam::VideoBLTeam( int id, int farbe, UIInit &uiFactory, char *n )
    : ReferenceCounter()
{
    teamId = id;
    spielerAnzahl = 0;
    p = 0;
    mP = 0;
    nP = 0;
    this->farbe = farbe;
    this->uiFactory = uiFactory;

    rahmen = new LRahmen();
    rahmen->setFarbe( farbe );
    rahmen->setRamenBreite( 1 );

    spieler = new RCArray< VideoBLSpieler >();

    name = uiFactory.createTextFeld( uiFactory.initParam );
    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    name->setSchriftFarbe( farbe );
    name->setSize( 100, 20 );
    name->setPosition( 0, 0 );
    name->setText( n );

    punkte = uiFactory.createTextFeld( uiFactory.initParam );
    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    punkte->setSchriftFarbe( farbe );
    punkte->setSize( 100, 20 );
    punkte->setPosition( 100, 0 );
    punkte->setText( "" );

    neuPunkte = uiFactory.createTextFeld( uiFactory.initParam );
    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    neuPunkte->setSchriftFarbe( farbe );
    neuPunkte->setSize( 100, 20 );
    neuPunkte->setPosition( 200, 0 );
    neuPunkte->setText( "" );

    status = uiFactory.createTextFeld( uiFactory.initParam );
    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    status->setSchriftFarbe( 0xFF00FF00 );
    status->setSize( 100, 20 );
    status->setPosition( 300, 0 );
    status->setText( "lebt" );

    rundenNP = new Array< int >();
    runde = 0;
}

// Destruktor
VideoBLTeam::~VideoBLTeam()
{
    rahmen->release();
    spieler->release();
    name->release();
    punkte->release();
    neuPunkte->release();
    status->release();
    rundenNP->release();
}

// nicht constant
bool VideoBLTeam::addSpieler( VideoSpieler *zSpieler )
{
    bool gefunden = 0;
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
        {
            gefunden = 1;
            break;
        }
    }
    if( gefunden )
        return 0;
    VideoBLSpieler *tmp = new VideoBLSpieler( zSpieler->getSpielerNummer(), zSpieler->getFarbe(), uiFactory );
    spieler->set( tmp, spielerAnzahl );
    spielerAnzahl++;
    return 1;
}

bool VideoBLTeam::updateSpielerStatus( VideoSpieler *zSpieler )
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
        {
            spieler->z( i )->updateStatus( zSpieler );
            return 1;
        }
    }
    return 0;
}

void VideoBLTeam::setStatus( const char *txt, int f )
{
    status->setText( txt );
    status->setSchriftFarbe( f );
}

void VideoBLTeam::setPunkte( int p )
{
    this->p = p;
}

void VideoBLTeam::setMaxPunkte( int mP )
{
    this->mP = mP;
}

bool VideoBLTeam::setSpielerPunkte( int sNum, int p )
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == sNum )
        {
            spieler->z( i )->setPunkte( p );
            return 1;
        }
    }
    return 0;
}

void VideoBLTeam::addPunkt( bool plus )
{
    if( plus )
        nP++;
    else
        nP--;
}

bool VideoBLTeam::addPunkt( int sNum, bool plus )
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == sNum )
        {
            spieler->z( i )->addPunkt( plus );
            return 1;
        }
    }
    return 0;
}

void VideoBLTeam::updatePunkte( bool vorwärts )
{
    if( vorwärts )
    {
        p += nP;
        rundenNP->set( nP, runde );
        nP = 0;
        runde++;
    }
    else
    {
        runde--;
        nP = rundenNP->get( runde );
        p -= nP;
    }
    for( int i = 0; i < spielerAnzahl; i++ )
        spieler->z( i )->updatePunkte( vorwärts );
}

void VideoBLTeam::render( int y, Bild &zRObj )
{
    rahmen->setSize( 402, 21 + 20 * spielerAnzahl );
    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
        return;
    punkte->setText( "" );
    if( nP == 0 )
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
    }
    else if( nP > 0 )
    {
        neuPunkte->setText( "+" );
        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
    }
    else
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
    }
    punkte->zText()->append( p > 0 ? p : 0 );
    punkte->zText()->append( "/" );
    punkte->zText()->append( mP );
    neuPunkte->zText()->append( nP );
    rahmen->render( zRObj );
    name->render( zRObj );
    punkte->render( zRObj );
    neuPunkte->render( zRObj );
    status->render( zRObj );
    Array< bool > *gemahlt = new Array< bool >();
    for( int i = 0; i < spielerAnzahl; i++ )
        gemahlt->set( 0, i );
    int min = -1;
    int tmp = -1;
    for( int h = 0; h < spielerAnzahl; h++ )
    {
        min = -1;
        tmp = -1;
        for( int i = 0; i < spielerAnzahl; i++ )
        {
            if( !spieler->z( i ) )
                continue;
            if( gemahlt->hat( i ) && gemahlt->get( i ) )
                continue;
            int p = spieler->z( i )->getPunkte();
            if( p > min )
            {
                min = p;
                tmp = i;
            }
        }
        if( tmp >= 0 )
        {
            gemahlt->set( 1, tmp );
            spieler->z( tmp )->render( 20 + 20 * h, zRObj );
        }
        else
            break;
    }
    gemahlt->release();
    zRObj.releaseDrawOptions();
}

// constant
int VideoBLTeam::getSpielerAnzahl() const
{
    return spielerAnzahl;
}

int VideoBLTeam::getPunkte() const
{
    return ( p + nP ) < 0 ? 0 : ( p + nP );
}

int VideoBLTeam::getHeight() const
{
    return 21 + spielerAnzahl * 20;
}

bool VideoBLTeam::hatGewonnen() const
{
    return p + nP >= mP;
}

int VideoBLTeam::getSpielerPunkte( int sNum ) const
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == sNum )
            return spieler->z( i )->getPunkte();
    }
    return 0;
}

// Inhalt der VideoBestenliste Klasse aus VideoBestenliste.h
// Konstruktor
VideoBestenliste::VideoBestenliste( UIInit &uiFactory )
    : ReferenceCounter()
{
    rahmen = new LRahmen();
    rahmen->setRamenBreite( 1 );
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setSize( 420, 200 );

    teams = new RCArray< VideoBLTeam >();

    name = uiFactory.createTextFeld( uiFactory.initParam );
    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    name->setText( "Name" );
    name->setSize( 100, 20 );
    name->setPosition( 0, 0 );

    punkte = uiFactory.createTextFeld( uiFactory.initParam );
    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    punkte->setText( "Punkte" );
    punkte->setSize( 100, 20 );
    punkte->setPosition( 100, 0 );

    neuPunkte = uiFactory.createTextFeld( uiFactory.initParam );
    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    neuPunkte->setText( "+Punkte" );
    neuPunkte->setSize( 100, 20 );
    neuPunkte->setPosition( 200, 0 );

    status = uiFactory.createTextFeld( uiFactory.initParam );
    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    status->setText( "Status" );
    status->setSize( 100, 20 );
    status->setPosition( 300, 0 );

    scroll = new VScrollBar();
    scroll->setKlickScroll( 7 );

    this->uiFactory = uiFactory;
    update = 0;
    teamAnzahl = 0;
}

// Destruktor
VideoBestenliste::~VideoBestenliste()
{
    rahmen->release();
    teams->release();
    name->release();
    punkte->release();
    neuPunkte->release();
    status->release();
    scroll->release();
}

// nicht constant
void VideoBestenliste::setTeamAnzahl( int anz )
{
    teamAnzahl = anz;
}

void VideoBestenliste::setTeamStatus( int team, const char *txt, int f )
{
    if( teams->z( team ) )
        teams->z( team )->setStatus( txt, f );
}

void VideoBestenliste::addSpieler( VideoSpieler *zSpieler )
{
    int team = zSpieler->getTeam();
    if( team < 0 )
        return;
    if( !teams->z( team ) )
        teams->set( new VideoBLTeam( team, zSpieler->getTeamFarbe(), uiFactory, zSpieler->zTeamName()->getText() ), team );
    teams->z( team )->addSpieler( zSpieler );
}

void VideoBestenliste::updateSpielerStatus( VideoSpieler *zSpieler )
{
    if( teams->z( zSpieler->getTeam() ) )
        teams->z( zSpieler->getTeam() )->updateSpielerStatus( zSpieler );
}

void VideoBestenliste::setTeamPunkte( int teamId, int punkte )
{
    if( teams->z( teamId ) )
        teams->z( teamId )->setPunkte( punkte );
}

void VideoBestenliste::setTeamMaxPunkte( int teamId, int mPunkte )
{
    if( teams->z( teamId ) )
        teams->z( teamId )->setMaxPunkte( mPunkte );
}

void VideoBestenliste::setSpielerPunkte( int teamNum, int sNum, int punkte )
{
    if( teams->z( teamNum ) )
        teams->z( teamNum )->setSpielerPunkte( sNum, punkte );
}

void VideoBestenliste::addPunkt( int tNum, bool plus )
{
    if( teams->z( tNum ) )
        teams->z( tNum )->addPunkt( plus );
}

void VideoBestenliste::addPunkt( int tNum, int sNum, bool plus )
{
    if( teams->z( tNum ) )
        teams->z( tNum )->addPunkt( sNum, plus );
}

void VideoBestenliste::updatePunkte( bool vorwärts )
{
    for( int i = 0; i < teamAnzahl; i++ )
    {
        if( teams->z( i ) )
            teams->z( i )->updatePunkte( vorwärts );
    }
}

void VideoBestenliste::doPublicMausEreignis( MausEreignis &me )
{
    scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
}

void VideoBestenliste::render( Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
        return;
    rahmen->render( zRObj );
    zRObj.addScrollOffset( 0, scroll->getScroll() );
    name->render( zRObj );
    punkte->render( zRObj );
    neuPunkte->render( zRObj );
    status->render( zRObj );
    int yOff = 20;
    Array< bool > *gemahlt = new Array< bool >();
    for( int i = 0; i < teamAnzahl; i++ )
        gemahlt->set( 0, i );
    int min = -1;
    int tmp = -1;
    for( int h = 0; h < teamAnzahl; h++ )
    {
        min = -1;
        tmp = -1;
        for( int i = 0; i < teamAnzahl; i++ )
        {
            if( !teams->z( i ) )
                continue;
            if( gemahlt->hat( i ) && gemahlt->get( i ) )
                continue;
            int p = teams->z( i )->getPunkte();
            if( p > min )
            {
                min = p;
                tmp = i;
            }
        }
        if( tmp >= 0 )
        {
            gemahlt->set( 1, tmp );
            teams->z( tmp )->render( yOff, zRObj );
            yOff += teams->z( tmp )->getHeight();
        }
        else
            break;
    }
    gemahlt->release();
    zRObj.addScrollOffset( 0, -scroll->getScroll() );
    scroll->update( yOff, rahmen->getHeight() - 2 );
    scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
    zRObj.releaseDrawOptions();
}

// constant
int VideoBestenliste::getTeamAnzahl() const
{
    return teamAnzahl;
}

bool VideoBestenliste::teamExistiert( int team ) const
{
    return teams->z( team ) != 0;
}

int VideoBestenliste::getTeamPunkte( int team ) const
{
    return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
}

bool VideoBestenliste::hatTeamGewonnen( int team ) const
{
    if( !teams->z( team ) )
        return 0;
    return teams->z( team )->hatGewonnen();
}

int VideoBestenliste::getSpielerPunkte( int team, int sNum ) const
{
    if( !teams->z( team ) )
        return 0;
    return teams->z( team )->getSpielerPunkte( sNum );
}