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

#include "ObjektOptionen.h"
#include "../../../../Initialisierung/Initialisierung.h"
#include <Textur2D.h>

using namespace Editor;

ObjektTool::ObjektTool(UIInit& uiFactory, KarteDaten* daten)
	: RightTool()
{
	dialog = 0;
	dialog2 = 0;
	this->uiFactory = uiFactory;
	this->daten = daten;
	objekte = uiFactory.createAuswahlListe(uiFactory.initParam);
	objekte->setStyle((AuswahlListe::Style::Normal & ~AuswahlListe::Style::FeldHAlpha) | AuswahlBox::Style::VScroll);
	objekte->setSize(290, 200);
	objekte->setVertikalKlickScroll(1);
	int anz = daten->getObjektAnzahl();
	for (int i = 0; i < anz; i++)
	{
		const ObjektDaten* o = daten->getObjekt(i);
		objekte->addEintrag(Text(o->id));
	}
	neuesObjekt = initKnopf(0, 205, 290, 20, uiFactory, Knopf::Style::Normal, "Neues Objekt erstellen");
	neuesObjekt->setMausEreignis([this, &uiFactory](void* p, void* o, MausEreignis me)
		{
			if (me.id == ME_RLinks)
			{
				cs.lock();
				if (dialog)
					dialog->release();
				dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this, &uiFactory](const char* modelPath)
					{
						if (!modelPath)
							return;
						cs.lock();
						if (dialog2)
							dialog2->release();
						dialog2 = dialog;
						dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this, modelPath](const char* texturPath)
							{
								if (!texturPath)
									return;
								this->daten->getResourceIdFromPath(modelPath, [this, texturPath](int modelId)
									{
										this->daten->getResourceIdFromPath(texturPath, [this, modelId](int texturId)
											{
												ObjektDaten o = ObjektDaten();
												o.m2d = modelId;
												o.bild = texturId;
												o.scale = 1;
												o.maxStabilität = 100;
												o.maxEnergie = 100;
												o.energieRadius = 0;
												o.reparatur = 0;
												o.akkuLeistung = 0;
												o.team = this->daten->getTeam(0)->id;
												o.pos.x = 0;
												o.pos.y = 0;
												o.rot = 0;
												o.style = 0;
												this->daten->addObjekt(o, [this](int id)
													{
														objekte->addEintrag(Text(id));
														selectObject(id);
													});
											});
									});
							}, screenSize);
						cs.unlock();
					}, screenSize);
				cs.unlock();
			}
			return 1;
		});
	model = new M2DVorschau();
	model->setStyle(M2DVorschau::Style::Rahmen | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrScale | M2DVorschau::Style::Erlaubt);
	model->setSize(290, 290);
	model->setPosition(0, 230);
	changeModel = initKnopf(0, 520, 142, 20, uiFactory, Knopf::Style::Normal, "Model ändern");
	changeModel->setMausEreignis([this, &uiFactory](void* p, void* o, MausEreignis me)
		{
			if (me.id == ME_RLinks)
			{
				cs.lock();
				if (dialog)
					dialog->release();
				dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this](const char* path)
					{
						if (!path)
							return;
						modelPath = path;
						Model2DData* data = this->daten->loadModelFromPath(modelPath);
						Textur2D* textur = new Textur2D();
						textur->setTexturZ(this->daten->loadBildFromPath(texturPath));
						model->postAction([this, data, textur]()
							{
								model->setModel2D(data);
								model->zModel()->setTextur(textur);
							});
					}, screenSize);
				cs.unlock();
			}
			return 1;
		});
	changeTextur = initKnopf(147, 520, 143, 20, uiFactory, Knopf::Style::Normal, "Textur ändern");
	changeTextur->setMausEreignis([this, &uiFactory](void* p, void* o, MausEreignis me)
		{
			if (me.id == ME_RLinks)
			{
				cs.lock();
				if (dialog)
					dialog->release();
				dialog = new ResourceDialog(new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis())), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten*>(this->daten->getThis()), [this](const char* path)
					{
						if (!path)
							return;
						texturPath = path;
						Textur2D* textur = new Textur2D();
						textur->setTexturZ(this->daten->loadBildFromPath(texturPath));
						model->postAction([this, textur]()
							{
								model->zModel()->setTextur(textur);
							});
					}, screenSize);
				cs.unlock();
			}
			return 1;
		});
	stabilitätT = initTextFeld(0, 545, 100, 20, uiFactory, TextFeld::Style::Text, "Stabilität: ");
	stabilität = initTextFeld(100, 545, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	energieT = initTextFeld(0, 570, 100, 20, uiFactory, TextFeld::Style::Text, "Energie: ");
	energie = initTextFeld(100, 570, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	energieRadiusT = initTextFeld(0, 595, 100, 20, uiFactory, TextFeld::Style::Text, "Radius: ");
	energieRadius = initTextFeld(100, 595, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	reparaturT = initTextFeld(0, 620, 100, 20, uiFactory, TextFeld::Style::Text, "Reparatur: ");
	reparatur = initTextFeld(100, 620, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	akkuLeistungT = initTextFeld(0, 645, 100, 20, uiFactory, TextFeld::Style::Text, "Akku: ");
	akkuLeistung = initTextFeld(100, 645, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	team = initAuswahlBox(0, 670, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {});
	anz = daten->getTeamAnzahl();
	for (int i = 0; i < anz; i++)
		team->addEintrag(daten->getTeamName(i));
	verwundbar = initKontrollKnopf(0, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Verwundbar");
	beweglich = initKontrollKnopf(150, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Beweglich");
	collision = initKontrollKnopf(0, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Kollision");
	laserCollision = initKontrollKnopf(150, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Laser Kollision");
	neutral = initKontrollKnopf(0, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Neutral");
	erfahrung = initKontrollKnopf(150, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Treffer Erfahrung");
	lebensAnzeige = initKontrollKnopf(0, 770, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Lebensanzeige");
	speichern = initKnopf(0, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern");
	speichern->setMausEreignis([this](void* p, void* o, MausEreignis me)
		{
			if (me.id == ME_RLinks)
			{
				ObjektDaten* o = this->daten->getObjekt(this->daten->getObjektIndexById((int)*objekte->zEintrag(objekte->getAuswahl())->zText()));
				this->daten->getResourceIdFromPath(modelPath, [this, o](int id)
					{
						o->m2d = id;
						this->daten->getResourceIdFromPath(texturPath, [this, o](int id)
							{
								o->bild = id;
								o->maxStabilität = (int)*stabilität->zText();
								o->maxEnergie = (int)*energie->zText();
								o->energieRadius = (int)*energieRadius->zText();
								o->reparatur = (double)*reparatur->zText();
								o->akkuLeistung = (double)*akkuLeistung->zText();
								o->team = team->getAuswahl();
								o->style = 0;
								if (verwundbar->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x1;
								if (beweglich->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x2;
								if (collision->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x4;
								if (laserCollision->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x8;
								if (neutral->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x10;
								if (erfahrung->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x20;
								if (lebensAnzeige->hatStyle(KontrollKnopf::Style::Selected))
									o->style |= 0x40;
								o->update();
							});
					});
			}
			return 1;
		});
	löschen = initKnopf(105, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Löschen");
	löschen->setMausEreignis([this](void* p, void* o, MausEreignis me)
		{
			if (me.id == ME_RLinks)
			{
				int ausw = objekte->getAuswahl();
				this->daten->removeObjekt(this->daten->getObjektIndexById((int)*objekte->zEintrag(objekte->getAuswahl())->zText()));
				selectObject(0);
				objekte->removeEintrag(ausw);
			}
			return 1;
		});
	selectObject(0);
}

ObjektTool::~ObjektTool()
{
	cs.lock();
	if (dialog)
		dialog->release();
	if (dialog2)
		dialog2->release();
	cs.unlock();
	objekte->release();
	neuesObjekt->release();
	model->release();
	changeModel->release();
	changeTextur->release();
	stabilitätT->release();
	stabilität->release();
	energieT->release();
	energie->release();
	energieRadiusT->release();
	energieRadius->release();
	reparaturT->release();
	reparatur->release();
	akkuLeistungT->release();
	akkuLeistung->release();
	team->release();
	verwundbar->release();
	beweglich->release();
	collision->release();
	laserCollision->release();
	neutral->release();
	erfahrung->release();
	lebensAnzeige->release();
	speichern->release();
	löschen->release();
	daten->release();
}

void ObjektTool::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		me.verarbeitet = 1;
	Punkt tmpM(me.mx, me.my);
	me.mx = me.mx + screenSize.x - 300;
	me.my = me.my;
	cs.lock();
	if (dialog)
		dialog->doPublicMausEreignis(me);
	cs.unlock();
	me.mx = tmpM.x;
	me.my = tmpM.y;
	me.mx -= pos.x;
	me.my -= pos.y;
	team->doPublicMausEreignis(me);
	int ausw = objekte->getAuswahl();
	objekte->doPublicMausEreignis(me);
	if (objekte->getAuswahl() != ausw && objekte->getAuswahl() >= 0)
		selectObject((int)*objekte->zEintrag(objekte->getAuswahl())->zText());
	if (objekte->getAuswahl() != ausw && objekte->getAuswahl() < 0)
		selectObject(0);
	neuesObjekt->doPublicMausEreignis(me);
	model->doPublicMausEreignis(me);
	changeModel->doPublicMausEreignis(me);
	changeTextur->doPublicMausEreignis(me);
	stabilität->doPublicMausEreignis(me);
	energie->doPublicMausEreignis(me);
	energieRadius->doPublicMausEreignis(me);
	reparatur->doPublicMausEreignis(me);
	akkuLeistung->doPublicMausEreignis(me);
	verwundbar->doPublicMausEreignis(me);
	beweglich->doPublicMausEreignis(me);
	collision->doPublicMausEreignis(me);
	laserCollision->doPublicMausEreignis(me);
	neutral->doPublicMausEreignis(me);
	erfahrung->doPublicMausEreignis(me);
	lebensAnzeige->doPublicMausEreignis(me);
	speichern->doPublicMausEreignis(me);
	löschen->doPublicMausEreignis(me);
	me.mx += pos.x;
	me.my += pos.y;
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		me.verarbeitet = vera;
}

void ObjektTool::doTastaturEreignis(TastaturEreignis& te)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return;
	cs.lock();
	if (dialog)
		dialog->doTastaturEreignis(te);
	cs.unlock();
	model->doTastaturEreignis(te);
	stabilität->doTastaturEreignis(te);
	energie->doTastaturEreignis(te);
	energieRadius->doTastaturEreignis(te);
	reparatur->doTastaturEreignis(te);
	akkuLeistung->doTastaturEreignis(te);
}

bool ObjektTool::tick(double tickVal)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return RightTool::tick(tickVal);
	cs.lock();
	if (dialog)
		rend |= dialog->tick(tickVal);
	cs.unlock();
	rend |= objekte->tick(tickVal);
	rend |= neuesObjekt->tick(tickVal);
	rend |= model->tick(tickVal);
	rend |= changeModel->tick(tickVal);
	rend |= changeTextur->tick(tickVal);
	rend |= stabilität->tick(tickVal);
	rend |= energie->tick(tickVal);
	rend |= energieRadius->tick(tickVal);
	rend |= reparatur->tick(tickVal);
	rend |= akkuLeistung->tick(tickVal);
	rend |= team->tick(tickVal);
	rend |= verwundbar->tick(tickVal);
	rend |= beweglich->tick(tickVal);
	rend |= collision->tick(tickVal);
	rend |= laserCollision->tick(tickVal);
	rend |= neutral->tick(tickVal);
	rend |= erfahrung->tick(tickVal);
	rend |= lebensAnzeige->tick(tickVal);
	rend |= speichern->tick(tickVal);
	rend |= löschen->tick(tickVal);
	return RightTool::tick(tickVal);
}

void ObjektTool::render(Bild& rObj)
{
	screenSize = rObj.getSize();
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return;
	if (rObj.setDrawOptions(pos, gr))
	{
		objekte->render(rObj);
		neuesObjekt->render(rObj);
		model->render(rObj);
		changeModel->render(rObj);
		changeTextur->render(rObj);
		stabilitätT->render(rObj);
		stabilität->render(rObj);
		energieT->render(rObj);
		energie->render(rObj);
		energieRadiusT->render(rObj);
		energieRadius->render(rObj);
		reparaturT->render(rObj);
		reparatur->render(rObj);
		akkuLeistungT->render(rObj);
		akkuLeistung->render(rObj);
		verwundbar->render(rObj);
		beweglich->render(rObj);
		collision->render(rObj);
		laserCollision->render(rObj);
		neutral->render(rObj);
		erfahrung->render(rObj);
		lebensAnzeige->render(rObj);
		speichern->render(rObj);
		löschen->render(rObj);
		team->render(rObj);
		rObj.releaseDrawOptions();
	}
}

void ObjektTool::renderDialogs(Bild& rObj)
{
	cs.lock();
	if (dialog)
		dialog->render(rObj);
	cs.unlock();
}

void ObjektTool::selectObject(int id)
{
	if (id == 0)
	{
		model->removeStyle(M2DVorschau::Style::Sichtbar);
		changeModel->removeStyle(M2DVorschau::Style::Sichtbar);
		changeTextur->removeStyle(M2DVorschau::Style::Sichtbar);
		stabilitätT->removeStyle(M2DVorschau::Style::Sichtbar);
		stabilität->removeStyle(M2DVorschau::Style::Sichtbar);
		energieT->removeStyle(M2DVorschau::Style::Sichtbar);
		energie->removeStyle(M2DVorschau::Style::Sichtbar);
		energieRadiusT->removeStyle(M2DVorschau::Style::Sichtbar);
		energieRadius->removeStyle(M2DVorschau::Style::Sichtbar);
		reparaturT->removeStyle(M2DVorschau::Style::Sichtbar);
		reparatur->removeStyle(M2DVorschau::Style::Sichtbar);
		akkuLeistungT->removeStyle(M2DVorschau::Style::Sichtbar);
		akkuLeistung->removeStyle(M2DVorschau::Style::Sichtbar);
		team->removeStyle(M2DVorschau::Style::Sichtbar);
		verwundbar->removeStyle(KontrollKnopf::Style::Sichtbar);
		beweglich->removeStyle(KontrollKnopf::Style::Sichtbar);
		collision->removeStyle(KontrollKnopf::Style::Sichtbar);
		laserCollision->removeStyle(KontrollKnopf::Style::Sichtbar);
		neutral->removeStyle(KontrollKnopf::Style::Sichtbar);
		erfahrung->removeStyle(KontrollKnopf::Style::Sichtbar);
		lebensAnzeige->removeStyle(KontrollKnopf::Style::Sichtbar);
		speichern->removeStyle(M2DVorschau::Style::Sichtbar);
		löschen->removeStyle(KontrollKnopf::Style::Sichtbar);
	}
	else
	{
		int index = 0;
		int anz = objekte->getEintragAnzahl();
		for (int i = 0; i < anz; i++)
		{
			if (objekte->zEintrag(i)->zText()->istGleich(Text(id)))
				break;
			index++;
		}
		objekte->setAuswahl(index);
		ObjektDaten* o = daten->getObjekt(daten->getObjektIndexById(id));
		model->setModel2D(daten->loadModelFromRessource(o->m2d));
		model->zModel()->addStyle(Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Erlaubt);
		modelPath = daten->getResource(daten->getResourceIndexById(o->m2d))->path;
		Textur2D* textur = new Textur2D();
		textur->setTexturZ(daten->loadBildFromRessource(o->bild));
		texturPath = daten->getResource(daten->getResourceIndexById(o->bild))->path;
		model->zModel()->setTextur(textur);
		stabilität->setText(Text(o->maxStabilität));
		energie->setText(Text(o->maxEnergie));
		energieRadius->setText(Text(o->energieRadius));
		reparatur->setText(Text(o->reparatur));
		akkuLeistung->setText(Text(o->akkuLeistung));
		team->setAuswahl((int)o->team);
		model->addStyle(M2DVorschau::Style::Sichtbar);
		verwundbar->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x1) == o->style);
		beweglich->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x2) == o->style);
		collision->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x4) == o->style);
		laserCollision->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x8) == o->style);
		neutral->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x10) == o->style);
		erfahrung->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x20) == o->style);
		lebensAnzeige->setStyle(KontrollKnopf::Style::Selected, (o->style | 0x40) == o->style);
		changeModel->addStyle(M2DVorschau::Style::Sichtbar);
		changeTextur->addStyle(M2DVorschau::Style::Sichtbar);
		stabilitätT->addStyle(M2DVorschau::Style::Sichtbar);
		stabilität->addStyle(M2DVorschau::Style::Sichtbar);
		energieT->addStyle(M2DVorschau::Style::Sichtbar);
		energie->addStyle(M2DVorschau::Style::Sichtbar);
		energieRadiusT->addStyle(M2DVorschau::Style::Sichtbar);
		energieRadius->addStyle(M2DVorschau::Style::Sichtbar);
		reparaturT->addStyle(M2DVorschau::Style::Sichtbar);
		reparatur->addStyle(M2DVorschau::Style::Sichtbar);
		akkuLeistungT->addStyle(M2DVorschau::Style::Sichtbar);
		akkuLeistung->addStyle(M2DVorschau::Style::Sichtbar);
		team->addStyle(M2DVorschau::Style::Sichtbar);
		verwundbar->addStyle(KontrollKnopf::Style::Sichtbar);
		beweglich->addStyle(KontrollKnopf::Style::Sichtbar);
		collision->addStyle(KontrollKnopf::Style::Sichtbar);
		laserCollision->addStyle(KontrollKnopf::Style::Sichtbar);
		neutral->addStyle(KontrollKnopf::Style::Sichtbar);
		erfahrung->addStyle(KontrollKnopf::Style::Sichtbar);
		lebensAnzeige->addStyle(KontrollKnopf::Style::Sichtbar);
		speichern->addStyle(M2DVorschau::Style::Sichtbar);
		löschen->addStyle(KontrollKnopf::Style::Sichtbar);
	}
}