Asteroids-Online-Client/Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.cpp

#include "SpielerOptionen.h"
#include "../../../../Initialisierung/Initialisierung.h"
#include "../../../Karte/EditorKarte.h"

using namespace Editor;

SpielerTool::SpielerTool(UIInit& uiFactory, KarteDaten* daten)
	: RightTool()
{
	int spielerAnzahl = daten->getSpielerAnzahl();
	spielerAuswahl = initAuswahlBox(0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {});
	for (int i = 0; i < spielerAnzahl; i++)
	{
		spielerAuswahl->addEintrag(new Text(Text("Spieler ") += (i + 1)));
	}
	spielerAuswahl->setEventAktion([this](void* p, AuswahlBox* a, int old, int auswahl)
		{
			this->selectPlayer(auswahl + 1);
		});
	skillStartT = initTextFeld(0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---");
	skillStartStabilitätT = initTextFeld(0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität");
	skillStartEnergieT = initTextFeld(0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie");
	skillStartReparaturT = initTextFeld(0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur");
	skillStartAkkuT = initTextFeld(0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku");
	skillStartWendigkeitT = initTextFeld(0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit");
	skillStartBeschleunigungT = initTextFeld(0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung");
	skillStartAntriebEffizienzT = initTextFeld(0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz");
	skillStartLaserIntensitätT = initTextFeld(0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität");
	skillStartLaserEffizienzT = initTextFeld(0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz");
	skillStartLaserTempoT = initTextFeld(0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo");
	skillStartEnergieSchildT = initTextFeld(0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild");
	skillStartEnergieSchildEffizienzT = initTextFeld(0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz");
	skillStartNetzwerkT = initTextFeld(0, 355, 200, 20, uiFactory, TextFeld::Style::Text, "Netzwerk");
	skillStartPunkteT = initTextFeld(0, 380, 200, 20, uiFactory, TextFeld::Style::Text, "Punkte");
	SpielerDaten* spieler = daten->getSpieler(daten->getSpielerIndexById(1));
	skillStartStabilität = initTextFeld(200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->maxStabilität));
	skillStartEnergie = initTextFeld(200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->maxEnergie));
	skillStartReparatur = initTextFeld(200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->reparatur));
	skillStartAkku = initTextFeld(200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->akkuLeistung));
	skillStartWendigkeit = initTextFeld(200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->wendigkeit));
	skillStartBeschleunigung = initTextFeld(200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->beschleunigung));
	skillStartAntriebEffizienz = initTextFeld(200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->antriebEffizienz));
	skillStartLaserIntensität = initTextFeld(200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->laserIntensität));
	skillStartLaserEffizienz = initTextFeld(200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->laserEffizienz));
	skillStartLaserTempo = initTextFeld(200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->laserTempo));
	skillStartEnergieSchild = initTextFeld(200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->energieSchild));
	skillStartEnergieSchildEffizienz = initTextFeld(200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->energieSchildEffizienz));
	skillStartNetzwerk = initTextFeld(200, 355, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->netzwerk));
	skillStartPunkte = initTextFeld(200, 380, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(spieler->skillPunkte));
	speichern = initKnopf(0, 405, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern");
	this->daten = daten;
}

SpielerTool::~SpielerTool()
{
	spielerAuswahl->release();
	skillStartT->release();
	skillStartStabilitätT->release();
	skillStartEnergieT->release();
	skillStartReparaturT->release();
	skillStartAkkuT->release();
	skillStartWendigkeitT->release();
	skillStartBeschleunigungT->release();
	skillStartAntriebEffizienzT->release();
	skillStartLaserIntensitätT->release();
	skillStartLaserEffizienzT->release();
	skillStartLaserTempoT->release();
	skillStartEnergieSchildT->release();
	skillStartEnergieSchildEffizienzT->release();
	skillStartNetzwerkT->release();
	skillStartPunkteT->release();
	skillStartStabilität->release();
	skillStartEnergie->release();
	skillStartReparatur->release();
	skillStartAkku->release();
	skillStartWendigkeit->release();
	skillStartBeschleunigung->release();
	skillStartAntriebEffizienz->release();
	skillStartLaserIntensität->release();
	skillStartLaserEffizienz->release();
	skillStartLaserTempo->release();
	skillStartEnergieSchild->release();
	skillStartEnergieSchildEffizienz->release();
	skillStartNetzwerk->release();
	skillStartPunkte->release();
	speichern->release();
	daten->release();
}

void SpielerTool::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		me.verarbeitet = 1;
	me.mx -= pos.x;
	me.my -= pos.y;
	spielerAuswahl->doPublicMausEreignis(me);
	skillStartT->doPublicMausEreignis(me);
	skillStartStabilitätT->doPublicMausEreignis(me);
	skillStartEnergieT->doPublicMausEreignis(me);
	skillStartReparaturT->doPublicMausEreignis(me);
	skillStartAkkuT->doPublicMausEreignis(me);
	skillStartWendigkeitT->doPublicMausEreignis(me);
	skillStartBeschleunigungT->doPublicMausEreignis(me);
	skillStartAntriebEffizienzT->doPublicMausEreignis(me);
	skillStartLaserIntensitätT->doPublicMausEreignis(me);
	skillStartLaserEffizienzT->doPublicMausEreignis(me);
	skillStartLaserTempoT->doPublicMausEreignis(me);
	skillStartEnergieSchildT->doPublicMausEreignis(me);
	skillStartEnergieSchildEffizienzT->doPublicMausEreignis(me);
	skillStartNetzwerkT->doPublicMausEreignis(me);
	skillStartPunkteT->doPublicMausEreignis(me);
	skillStartStabilität->doPublicMausEreignis(me);
	skillStartEnergie->doPublicMausEreignis(me);
	skillStartReparatur->doPublicMausEreignis(me);
	skillStartAkku->doPublicMausEreignis(me);
	skillStartWendigkeit->doPublicMausEreignis(me);
	skillStartBeschleunigung->doPublicMausEreignis(me);
	skillStartAntriebEffizienz->doPublicMausEreignis(me);
	skillStartLaserIntensität->doPublicMausEreignis(me);
	skillStartLaserEffizienz->doPublicMausEreignis(me);
	skillStartLaserTempo->doPublicMausEreignis(me);
	skillStartEnergieSchild->doPublicMausEreignis(me);
	skillStartEnergieSchildEffizienz->doPublicMausEreignis(me);
	skillStartNetzwerk->doPublicMausEreignis(me);
	skillStartPunkte->doPublicMausEreignis(me);
	bool verarbeitet = me.verarbeitet;
	speichern->doPublicMausEreignis(me);
	if (!verarbeitet && me.verarbeitet && me.id == ME_RLinks)
	{
		SpielerDaten* data = daten->getSpieler(daten->getSpielerIndexById(spielerAuswahl->getAuswahl() + 1));
		data->maxStabilität = (int)*skillStartStabilität->zText();
		data->maxEnergie = (int)*skillStartEnergie->zText();
		data->reparatur = (double)*skillStartReparatur->zText();
		data->akkuLeistung = (double)*skillStartAkku->zText();
		data->wendigkeit = (double)*skillStartWendigkeit->zText();
		data->beschleunigung = (double)*skillStartBeschleunigung->zText();
		data->antriebEffizienz = (double)*skillStartAntriebEffizienz->zText();
		data->laserIntensität = (int)*skillStartLaserIntensität->zText();
		data->laserEffizienz = (int)*skillStartLaserEffizienz->zText();
		data->laserTempo = (int)*skillStartLaserTempo->zText();
		data->energieSchild = (double)*skillStartEnergieSchild->zText();
		data->energieSchildEffizienz = (double)*skillStartEnergieSchildEffizienz->zText();
		data->netzwerk = (int)*skillStartNetzwerk->zText();
		data->skillPunkte = (int)*skillStartPunkte->zText();
		data->update();
	}
	me.mx += pos.x;
	me.my += pos.y;
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		me.verarbeitet = vera;
}

void SpielerTool::doTastaturEreignis(TastaturEreignis& te)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return;
	spielerAuswahl->doTastaturEreignis(te);
	skillStartT->doTastaturEreignis(te);
	skillStartStabilitätT->doTastaturEreignis(te);
	skillStartEnergieT->doTastaturEreignis(te);
	skillStartReparaturT->doTastaturEreignis(te);
	skillStartAkkuT->doTastaturEreignis(te);
	skillStartWendigkeitT->doTastaturEreignis(te);
	skillStartBeschleunigungT->doTastaturEreignis(te);
	skillStartAntriebEffizienzT->doTastaturEreignis(te);
	skillStartLaserIntensitätT->doTastaturEreignis(te);
	skillStartLaserEffizienzT->doTastaturEreignis(te);
	skillStartLaserTempoT->doTastaturEreignis(te);
	skillStartEnergieSchildT->doTastaturEreignis(te);
	skillStartEnergieSchildEffizienzT->doTastaturEreignis(te);
	skillStartNetzwerkT->doTastaturEreignis(te);
	skillStartPunkteT->doTastaturEreignis(te);
	skillStartStabilität->doTastaturEreignis(te);
	skillStartEnergie->doTastaturEreignis(te);
	skillStartReparatur->doTastaturEreignis(te);
	skillStartAkku->doTastaturEreignis(te);
	skillStartWendigkeit->doTastaturEreignis(te);
	skillStartBeschleunigung->doTastaturEreignis(te);
	skillStartAntriebEffizienz->doTastaturEreignis(te);
	skillStartLaserIntensität->doTastaturEreignis(te);
	skillStartLaserEffizienz->doTastaturEreignis(te);
	skillStartLaserTempo->doTastaturEreignis(te);
	skillStartEnergieSchild->doTastaturEreignis(te);
	skillStartEnergieSchildEffizienz->doTastaturEreignis(te);
	skillStartNetzwerk->doTastaturEreignis(te);
	skillStartPunkte->doTastaturEreignis(te);
	speichern->doTastaturEreignis(te);
}

bool SpielerTool::tick(double tickVal)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return __super::tick(tickVal);
	bool ret = __super::tick(tickVal);
	ret |= spielerAuswahl->tick(tickVal);
	ret |= skillStartT->tick(tickVal);
	ret |= skillStartStabilitätT->tick(tickVal);
	ret |= skillStartEnergieT->tick(tickVal);
	ret |= skillStartReparaturT->tick(tickVal);
	ret |= skillStartAkkuT->tick(tickVal);
	ret |= skillStartWendigkeitT->tick(tickVal);
	ret |= skillStartBeschleunigungT->tick(tickVal);
	ret |= skillStartAntriebEffizienzT->tick(tickVal);
	ret |= skillStartLaserIntensitätT->tick(tickVal);
	ret |= skillStartLaserEffizienzT->tick(tickVal);
	ret |= skillStartLaserTempoT->tick(tickVal);
	ret |= skillStartEnergieSchildT->tick(tickVal);
	ret |= skillStartEnergieSchildEffizienzT->tick(tickVal);
	ret |= skillStartNetzwerkT->tick(tickVal);
	ret |= skillStartPunkteT->tick(tickVal);
	ret |= skillStartStabilität->tick(tickVal);
	ret |= skillStartEnergie->tick(tickVal);
	ret |= skillStartReparatur->tick(tickVal);
	ret |= skillStartAkku->tick(tickVal);
	ret |= skillStartWendigkeit->tick(tickVal);
	ret |= skillStartBeschleunigung->tick(tickVal);
	ret |= skillStartAntriebEffizienz->tick(tickVal);
	ret |= skillStartLaserIntensität->tick(tickVal);
	ret |= skillStartLaserEffizienz->tick(tickVal);
	ret |= skillStartLaserTempo->tick(tickVal);
	ret |= skillStartEnergieSchild->tick(tickVal);
	ret |= skillStartEnergieSchildEffizienz->tick(tickVal);
	ret |= skillStartNetzwerk->tick(tickVal);
	ret |= skillStartPunkte->tick(tickVal);
	ret |= speichern->tick(tickVal);
	return ret;
}

void SpielerTool::render(Bild& rObj)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return;
	if (rObj.setDrawOptions(pos, gr))
	{
		skillStartT->render(rObj);
		skillStartStabilitätT->render(rObj);
		skillStartEnergieT->render(rObj);
		skillStartReparaturT->render(rObj);
		skillStartAkkuT->render(rObj);
		skillStartWendigkeitT->render(rObj);
		skillStartBeschleunigungT->render(rObj);
		skillStartAntriebEffizienzT->render(rObj);
		skillStartLaserIntensitätT->render(rObj);
		skillStartLaserEffizienzT->render(rObj);
		skillStartLaserTempoT->render(rObj);
		skillStartEnergieSchildT->render(rObj);
		skillStartEnergieSchildEffizienzT->render(rObj);
		skillStartNetzwerkT->render(rObj);
		skillStartPunkteT->render(rObj);
		skillStartStabilität->render(rObj);
		skillStartEnergie->render(rObj);
		skillStartReparatur->render(rObj);
		skillStartAkku->render(rObj);
		skillStartWendigkeit->render(rObj);
		skillStartBeschleunigung->render(rObj);
		skillStartAntriebEffizienz->render(rObj);
		skillStartLaserIntensität->render(rObj);
		skillStartLaserEffizienz->render(rObj);
		skillStartLaserTempo->render(rObj);
		skillStartEnergieSchild->render(rObj);
		skillStartEnergieSchildEffizienz->render(rObj);
		skillStartNetzwerk->render(rObj);
		skillStartPunkte->render(rObj);
		speichern->render(rObj);
		spielerAuswahl->render(rObj);
		rObj.releaseDrawOptions();
	}
}

void SpielerTool::selectPlayer(int id)
{
	int index = daten->getSpielerIndexById(id);
	spielerAuswahl->setAuswahl(id - 1);
	SpielerDaten* spieler = daten->getSpieler(index);
	skillStartStabilität->setText(Text(spieler->maxStabilität));
	skillStartEnergie->setText(Text(spieler->maxEnergie));
	skillStartReparatur->setText(Text(spieler->reparatur));
	skillStartAkku->setText(Text(spieler->akkuLeistung));
	skillStartWendigkeit->setText(Text(spieler->wendigkeit));
	skillStartBeschleunigung->setText(Text(spieler->beschleunigung));
	skillStartAntriebEffizienz->setText(Text(spieler->antriebEffizienz));
	skillStartLaserIntensität->setText(Text(spieler->laserIntensität));
	skillStartLaserEffizienz->setText(Text(spieler->laserEffizienz));
	skillStartLaserTempo->setText(Text(spieler->laserTempo));
	skillStartEnergieSchild->setText(Text(spieler->energieSchild));
	skillStartEnergieSchildEffizienz->setText(Text(spieler->energieSchildEffizienz));
	skillStartNetzwerk->setText(Text(spieler->netzwerk));
	skillStartPunkte->setText(Text(spieler->skillPunkte));
}