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, const 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);
}