KSG-Client/KSGClient/NachLogin/MiniGames/Minigames.cpp

#include "MiniGames.h"
#include <Punkt.h>
#include <Rahmen.h>
#include "../../Global/Variablen.h"
#include <Datei.h>
#include "../../Global/Initialisierung.h"
#include <InitDatei.h>
#include <KSGTDatei.h>
#include <Globals.h>

typedef MiniGameV* (*GetMiniGame)();

// Inhalt der MGLaden Klasse aus MiniGames.h
// Konstruktor
MGSuchen::MGSuchen(MiniGames* mGames)
{
	this->mGames = mGames;
	start();
}

// Destruktor
MGSuchen::~MGSuchen()
{
	mGames->release();
}

// nicht constant
void MGSuchen::thread()
{
	KSGTDatei* dgt = new KSGTDatei("data/dg.ksgt");
	dgt->laden();
	bool ak = 0;
	int dgId = infoClient->getDateiGruppeIdVonPfad("data/Minigames");
	for (int i = 0; i < dgt->getZeilenAnzahl(); i++)
	{
		if (dgt->zFeld(i, 0) && TextZuInt(dgt->zFeld(i, 0)->getText(), 10) == dgId)
		{
			int lv = dgt->zFeld(i, 2) ? TextZuInt(dgt->zFeld(i, 2)->getText(), 10) : 0;
			int ov = infoClient->getDateiGruppeVersion(dgId);
			if (lv == ov)
				ak = 1;
			break;
		}
	}
	dgt->release();
	if (!ak)
	{
		mGames->setAktuell(0, dgId);
		delete this;
		return;
	}
	Datei* d = new Datei();
	d->setDatei("data/Minigames");
	if (!d->existiert())
		DateiPfadErstellen("data/MiniGames/");
	RCArray< Text >* list = d->getDateiListe();
	if (list)
	{
		for (int i = 0; i < list->getEintragAnzahl(); i++)
		{
			MiniGame* mg = new MiniGame(list->z(i)->getText());
			if (!mg->istOk())
			{
				mg->release();
				continue;
			}
			mGames->addMiniGame(mg);
		}
		list->release();
	}
	d->release();
	delete this;
}


// Inhalt der MGLaden Klasse aus MiniGameV.h
// Konstruktor
MGLaden::MGLaden(const char* name)
{
	this->name = new Text(name);
	game = 0;
	start();
}

// Destruktor
MGLaden::~MGLaden()
{
	if (game)
	{
		game->release();
		Framework::getDLLRegister()->releaseDLL(name->getText());
	}
	name->release();
}

// nicht constant
void MGLaden::thread()
{
	Text* pfad = new Text("data/Minigames/");
	pfad->append(name->getText());
	if (!DateiExistiert(pfad->getText()))
	{
		pfad->release();
		run = 0;
		return;
	}
	pfad->append("/mg.ini");
	if (!DateiExistiert(pfad->getText()))
	{
		pfad->release();
		run = 0;
		return;
	}
	InitDatei* mgIni = new InitDatei(pfad);
	if (!mgIni->laden())
	{
		mgIni->release();
		run = 0;
		return;
	}
	if (!mgIni->wertExistiert("DllPfad"))
	{
		mgIni->release();
		run = 0;
		return;
	}
	Text* dllPfad = new Text("data/Minigames/");
	dllPfad->append(name->getText());
	dllPfad->append("/");
	dllPfad->append(mgIni->zWert("DllPfad")->getText());
	mgIni->release();
	if (!DateiExistiert(dllPfad->getText()))
	{
		dllPfad->release();
		run = 0;
		return;
	}
	HMODULE dll = Framework::getDLLRegister()->ladeDLL(name->getText(), dllPfad->getText());
	dllPfad->release();
	if (!dll)
	{
		run = 0;
		return;
	}
	GetMiniGame getMiniGame = (GetMiniGame)GetProcAddress(dll, "GetMiniGame");
	if (!getMiniGame)
	{
		Framework::getDLLRegister()->releaseDLL(name->getText());
		run = 0;
		return;
	}
	game = getMiniGame();
	if (!game)
	{
		Framework::getDLLRegister()->releaseDLL(name->getText());
		run = 0;
		return;
	}
	if (!minigameClient)
		minigameClient = mainClient->createMinigameServerClient();
	if (minigameClient)
		game->setMinigameClientZ(dynamic_cast<KSGClient::MinigameServerClient*>(minigameClient->getThis()));
	if (!game->laden())
	{
		game = (MiniGameV*)game->release();
		Framework::getDLLRegister()->releaseDLL(name->getText());
	}
	run = 0;
}

// constant
bool MGLaden::fertig() const
{
	return !isRunning();
}

MiniGameV* MGLaden::zGame() const
{
	return game;
}


// Inhalt der MiniGames Klasse aus MiniGames.h
// Konstruktor
MiniGames::MiniGames(Fenster* zNachLoginFenster, int x)
	: Zeichnung()
{
	bildschirmGröße = uiFactory.initParam.bildschirm->getBackBufferSize();
	pos = Punkt(x, 67);
	gr = Punkt(102, 32);
	rahmen = new LRahmen();
	rahmen->setFarbe(0xFFFFFFFF);
	rahmen->setSize(102, 32);
	alpha = 0;
	alpha2 = 0;
	animation = 0;
	sichtbar = 0;
	tickVal = 0;
	prozent1 = 0;
	prozent2 = 0;
	begPos = Punkt(0, 0);
	begGröße = Punkt(0, 0);
	größe1 = Punkt(102, 32);
	pos1 = Punkt(x, 67);
	größe2 = Punkt(800, 500);
	pos2 = bildschirmGröße / 2 - größe2 / 2;
	laden = (Animation2D*)ladeAnimation->dublizieren();
	laden->setSichtbar(0);
	laden->setPosition(375, 225);
	games = new RCArray< MiniGame >();
	suchFilter = initTextFeld(10, 10, 100, 20, TextFeld::Style::Text | TextFeld::Style::VCenter, "Suchfilter:");
	TextRenderer tr(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
	tr.setSchriftSize(12);
	suchFilter->setSize(tr.getTextBreite(suchFilter->zText()->getText()), 20);
	suchName = initTextFeld(20 + suchFilter->getBreite(), 10, 200, 20, TextFeld::Style::TextFeld, "");
	suchen = initKnopf(230 + suchFilter->getBreite(), 10, 100, 20, Knopf::Style::Sichtbar, "Suchen");
	gefiltert = 0;
	getThis();
	zNachLoginFenster->addMember(this);
	dg = 0;
	mgl = 0;
	mgInitialized = 0;
	fullscreen = 0;
	slo = 0;
	minAlpha = 0;
	getThis();
	new MGSuchen(this);
}

// Destruktor
MiniGames::~MiniGames()
{
	rahmen->release();
	suchName->release();
	suchFilter->release();
	suchen->release();
	laden->release();
	games->release();
	if (mgl)
		mgl->release();
}

// nicht constant
void MiniGames::setSichtbar(bool sicht)
{
	begPos = pos;
	begGröße = gr;
	animation |= (sicht ? 0x1 : 0x2);
	rend = 1;
}

void MiniGames::addMiniGame(MiniGame* mg)
{
	games->add(mg);
	if (gefiltert)
		filter();
	else
	{
		int i = games->getEintragAnzahl() - 1;
		games->z(i)->setPosition(10 + 10 * (i % 3) + 250 * (i % 3), 50 + 10 * (i / 3) + 100 * (i / 3));
	}
}

void MiniGames::setAktuell(bool aktuell, int dg)
{
	this->aktuell = aktuell;
	if (aktuell)
		new MGSuchen(dynamic_cast<MiniGames*>(getThis()));
	if (!this->dg)
		this->dg = dg;
	if (!aktuell && !updateH->hat(dg))
	{
		nachLogin->zNachrichtenListe()->addNachricht(new SpielUpdateNachricht(new Text("Update"), new Text("Die minigames müssen aktualisiert werden."), dg,
			[]()
			{
				if (nachLogin && nachLogin->zMGFenster())
					nachLogin->zMGFenster()->setAktuell(1);
			}));
	}
}

void MiniGames::setFullScreenMode(bool enabled)
{
	fullscreen = enabled;
	if (fullscreen)
		nachLogin->hideBars();
	else
		nachLogin->showBars();
}

void MiniGames::showLoadingOverlay(unsigned char minAlpha)
{
	slo++;
	this->minAlpha = minAlpha;
	if (slo)
		laden->setSichtbar(1);
}

void MiniGames::hideLoadingOverlay()
{
	slo--;
	if (!slo)
		laden->setSichtbar(0);
}

Bild* MiniGames::loadBild(const char* path)
{
	return bilder->get(path);
}

void MiniGames::filter()
{
	Text filter = suchName->zText()->getText();
	bool notF = 0;
	if (!filter.getLength())
		notF = 1;
	int anz = games->getEintragAnzahl();
	bool* fertig = new bool[anz];
	for (int i = 0; i < anz; i++)
		fertig[i] = 0;
	for (int i = 0; i < anz; i++)
	{
		int pos = -1;
		int p = -1;
		for (int j = 0; j < anz; j++)
		{
			if ((notF || (games->z(j)->zName()->hat(filter) && (pos == -1 || games->z(j)->zName()->positionVon(filter) < pos))) && !fertig[j])
			{
				p = j;
				pos = games->z(j)->zName()->positionVon(filter);
				games->z(j)->setSichtbar(1);
			}
		}
		if (p < 0)
			break;
		fertig[p] = 1;
		games->z(p)->setPosition(10 + 10 * (i % 3) + 250 * (i % 3), 50 + 10 * (i / 3) + 100 * (i / 3));
	}
	for (int i = 0; i < anz; i++)
	{
		if (!fertig[i])
			games->z(i)->setSichtbar(0);
	}
	delete[] fertig;
}

void MiniGames::doPublicMausEreignis(MausEreignis& me)
{
	if (laden->istSichtbar() || !sichtbar)
		return;
	me.mx -= pos.x;
	me.my -= pos.y;
	if (alpha2)
	{
		suchName->doPublicMausEreignis(me);
		bool vera = me.verarbeitet;
		suchen->doPublicMausEreignis(me);
		if (!vera && me.verarbeitet && me.id == ME_RLinks)
			filter();
		int anz = games->getEintragAnzahl();
		for (int i = 0; i < anz; i++)
		{
			bool vera = me.verarbeitet;
			games->z(i)->doPublicMausEreignis(me);
			if (!vera && me.verarbeitet && me.id == ME_RLinks)
			{ // spiel starten
				laden->setSichtbar(1);
				if (mgl)
					mgl = (MGLaden*)mgl->release();
				mgInitialized = 0;
				mgl = new MGLaden(games->z(i)->zName()->getText());
			}
		}
	}
	if (!slo && mgl && mgl->zGame())
		mgl->zGame()->doPublicMausEreignis(me);
	me.mx += pos.x;
	me.my += pos.y;
}

void MiniGames::doTastaturEreignis(TastaturEreignis& te)
{
	if (laden->istSichtbar() || !sichtbar)
		return;
	if (alpha2)
	{
		bool vera = te.verarbeitet;
		suchName->doTastaturEreignis(te);
		if (!vera && te.verarbeitet && te.taste == T_Enter && te.id == TE_Release)
			filter();
	}
	if (!slo && mgl && mgl->zGame())
		mgl->zGame()->doTastaturEreignis(te);
}

bool MiniGames::tick(double z)
{
	if (laden->istSichtbar() && mgl && mgl->fertig())
	{
		if (!mgl->zGame())
		{
			mgl = (MGLaden*)mgl->release();
			nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"), new Text("Das Minigame konnte nicht geladen werden."), new Text("Ok"));
			mgInitialized = 0;
			slo = 0;
		}
		else if (!mgInitialized)
		{
			mgl->zGame()->setMinigameAPI(this);
			mgl->zGame()->setUIFactory(uiFactory);
			mgInitialized = 1;
		}
		if (!slo)
			laden->setSichtbar(0);
	}
	if (mgl && mgl->zGame() && !alpha2)
	{
		if (sichtbar && !animation)
			rend |= mgl->zGame()->tick(z);
		if (mgl->zGame()->istEnde())
		{
			mgl = (MGLaden*)mgl->release();
			mgInitialized = 0;
		}
	}
	rend |= laden->tick(z);
	if (alpha2)
	{
		rend |= suchName->tick(z);
		rend |= suchen->tick(z);
		int anz = games->getEintragAnzahl();
		for (int i = 0; i < anz; i++)
			rend |= games->z(i)->tick(z);
	}
	tickVal += z * 150;
	int val = (int)tickVal;
	if (val < 1)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	tickVal -= val;
	if ((animation | 0x1) == animation) // Einblenden
	{
		if (prozent1 != 100)
		{
			prozent1 += val;
			if (prozent1 >= 100)
				prozent1 = 100;
			pos = begPos + (Punkt)(((Vec2< double >)(pos2 - begPos) / 100.0) * prozent1);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe2 - begGröße) / 100.0) * prozent1);
		}
		else if (alpha != 255)
		{
			alpha += val * 2;
			if (alpha >= 255 || (animation | 0x2) == animation)
			{
				alpha = 255;
				animation &= ~0x1;
				sichtbar = 1;
				prozent1 = 0;
			}
		}
		else
		{
			animation &= ~0x1;
			prozent1 = 0;
			pos = pos2;
			gr = größe2;
		}
		rend = 1;
	}
	if ((animation | 0x2) == animation) // ausblenden
	{
		if (alpha != 0)
		{
			alpha -= val * 2;
			if (alpha < 0)
				alpha = 0;
		}
		else
		{
			prozent2 += val;
			if (prozent2 > 100)
				prozent2 = 100;
			pos = begPos + (Punkt)(((Vec2< double >)(pos1 - begPos) / 100.0) * prozent2);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe1 - begGröße) / 100.0) * prozent2);
			if (prozent2 == 100)
			{
				prozent2 = 0;
				animation &= ~0x2;
				sichtbar = 0;
			}
		}
		rend = 1;
	}
	if (!animation && sichtbar)
	{
		if (fullscreen)
		{
			if (pos != Punkt(0, 0))
			{
				pos -= Punkt(val, val) * 2;
				if (pos.x < 0)
					pos.x = 0;
				if (pos.y < 0)
					pos.y = 0;
			}
			if (gr != bildschirmGröße)
			{
				gr += Punkt(val, val) * 4;
				if (gr.x > bildschirmGröße.x - 1)
					gr.x = bildschirmGröße.x - 1;
				if (gr.y > bildschirmGröße.y - 1)
					gr.y = bildschirmGröße.y - 1;
			}
		}
		else
		{
			if (pos != pos2 || gr != größe2)
			{
				begPos = pos;
				begGröße = gr;
				animation |= 0x1;
			}
		}
		if (slo && alpha != minAlpha)
		{
			alpha -= val * 2;
			if (alpha < minAlpha)
				alpha = minAlpha;
		}
		else if (!slo && alpha != 255)
		{
			alpha += val * 2;
			if (alpha > 255)
				alpha = 255;
		}
	}
	if (mgl && alpha2)
	{
		alpha2 -= val;
		if (alpha2 < 0)
			alpha2 = 0;
		rend = 1;
	}
	if (!mgl && alpha2 != 255)
	{
		alpha2 += val;
		if (alpha2 > 255)
			alpha2 = 255;
		rend = 1;
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void MiniGames::render(Bild& zRObj)
{
	if (pos == pos1)
		return;
	rahmen->setPosition(pos);
	rahmen->setSize(gr);
	rahmen->render(zRObj);
	if (!zRObj.setDrawOptions(pos.x + 1, pos.y + 1, gr.x - 2, gr.y - 2))
		return;
	int rbr = rahmen->getRBreite();
	zRObj.setAlpha((unsigned char)alpha);
	zRObj.setAlpha((unsigned char)alpha2);
	suchFilter->render(zRObj);
	suchName->render(zRObj);
	suchen->render(zRObj);
	int anz = games->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
		games->z(i)->render(zRObj);
	zRObj.releaseAlpha();
	if (mgl && mgl->fertig() && mgl->zGame())
		mgl->zGame()->render(zRObj);
	zRObj.releaseAlpha();
	laden->setPosition(gr.x / 2 - laden->getBreite() / 2, gr.y / 2 - laden->getHeight() / 2);
	laden->render(zRObj);
	zRObj.releaseDrawOptions();
}

// constant
bool MiniGames::istAnimiert() const
{
	return animation != 0;
}

bool MiniGames::istSichtbar() const
{
	return sichtbar || prozent1 != 0;
}