KSG-Script/ksgScript/Main/KSGScriptObj.cpp

#include "KSGScriptObj.h"
#include "../Befehl/KSGSKlasse.h"
#include "../Leser/KSGSLeser.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <Punkt.h>
#include "../Klassen/KSGSMausEreignis.h"
#include "../Klassen/KSGSTastaturEreignis.h"
#include "../Klassen/KSGSInt.h"
#include "../Klassen/KSGSBild.h"
#include "../Klassen/KSGSDouble.h"
#include "../Error/Error.h"
#include <Bildschirm.h>
#include <Zeit.h>
#include <Datei.h>

using namespace KSGScript;

#ifndef WIN32
#define INFINITE 0xFFFFFFFF
#endif

// Inhalt der KSGScript Klasse aus KSGScript.h
// Konstruktor
KSGScriptO::KSGScriptO()
{
	pfad = new Text();
	wd = new Text();
	rParam = 0;
	rFunktion = 0;
	variablen = new RCArray< KSGSVariable >();
	funktionen = new RCArray< KSGSFunktion >();
	klassen = new RCArray< KSGSKlasse >();
	schrift = 0;
	screen = 0;
	mainId = 0;
	mausId = 0;
	tastaturId = 0;
	tickId = 0;
	renderId = 0;
	geladen = 0;
	scrId = 0;
	mausP = new RCArray< KSGSVariable >();
	tastaturP = new RCArray< KSGSVariable >();
	tickP = new RCArray< KSGSVariable >();
	renderP = new RCArray< KSGSVariable >();
	log = 0;
}

// Destruktor
KSGScriptO::~KSGScriptO()
{
	if (schrift)
		schrift->release();
	if (screen)
		screen->release();
	reset();
	mausP->release();
	tastaturP->release();
	tickP->release();
	renderP->release();
	pfad->release();
	wd->release();
	variablen->release();
	funktionen->release();
	klassen->release();
	if (log)
		log->release();
}

// nicht constant
void KSGScriptO::lock()
{
	cs.lock();
}

void KSGScriptO::unlock()
{
	cs.unlock();
}

void KSGScriptO::setScriptDatei(const char* pfad)
{
	this->pfad->setText(pfad);
	this->pfad->ersetzen('\\', '/');
	int l = this->pfad->hat('/') ? this->pfad->positionVon('/', this->pfad->anzahlVon('/') - 1) + 1 : 0;
	if (l)
		wd->setText(pfad, l);
}

void KSGScriptO::setScriptDatei(Text* pfad)
{
	setScriptDatei(pfad->getText());
	pfad->release();
}

bool KSGScriptO::neuLaden()
{
	lock();
	ZeitMesser* gzm = new ZeitMesser();
	gzm->messungStart();
	if (geladen)
		reset();
	scrId++;
	Datei* datei = new Datei();
	datei->setDatei(*pfad);
	if (!datei->open(Datei::Style::lesen))
	{
		datei->release();
		error(4, { *pfad }, this);
		return 0;
	}
	KSGSLeser* reader = new KSGSLeser(datei, this, *pfad);
	ZeitMesser* zm = new ZeitMesser();
	zm->messungStart();
	if (!reader->laden())
	{
		reader->release();
		datei->close();
		datei->release();
		zm->release();
		gzm->release();
		unlock();
		return 0;
	}
	zm->messungEnde();
	if (log)
	{
		Text msg = "Reader: Zum lesen benötigte Sekunden: ";
		msg += zm->getSekunden();
		logNachricht(msg);
	}
	std::cout << "KSGS Reader: Zum lesen benötigte Sekunden: " << zm->getSekunden() << "\n";
	Array< KSGSVariableDef* >* varDefs = new Array< KSGSVariableDef* >();
	zm->messungStart();
	if (!reader->compile(klassen, funktionen, varDefs))
	{
		varDefs->release();
		reader->release();
		datei->close();
		datei->release();
		zm->release();
		gzm->release();
		unlock();
		return 0;
	}
	mausP->add(new KSGSMausEreignisKlasse(this));
	tastaturP->add(new KSGSTastaturEreignisKlasse(this));
	tickP->add(new KSGSDoubleKlasse(this));
	renderP->add(new KSGSBildKlasse(this));
	zm->messungEnde();
	if (log)
	{
		Text msg = "Reader: Zum compilieren benötigte Sekunden: ";
		msg += zm->getSekunden();
		logNachricht(msg);
	}
	std::cout << "KSGS Reader: Zum compilieren benötigte Sekunden: " << zm->getSekunden() << "\n";
	zm->release();
	int vAnz = varDefs->getEintragAnzahl();
	for (int i = 0; i < vAnz; i++)
	{
		KSGSVariable* var = KSGSKlasseInstanz::erstellVariable(this, varDefs->get(i));
		if (var)
			variablen->add(var);
		delete varDefs->get(i);
	}
	varDefs->release();
	mainId = reader->getMainFuncId();
	mausId = reader->getMausFuncId();
	tastaturId = reader->getTastaturFuncId();
	tickId = reader->getTickFuncId();
	renderId = reader->getRenderFuncId();
	reader->release();
	datei->close();
	datei->release();
	int anz = funktionen->getEintragAnzahl();
	geladen = 1;
	for (int i = 0; i < anz; i++)
	{
		if (funktionen->z(i)->getId() == mainId)
		{
			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, 0);
			KSGSVariable* ret = inst->startFunktion();
			if (ret)
				ret->release();
			if (inst->isFunctionExecuting())
				inst->warteAufFunktion(INFINITE);
			inst->release();
			break;
		}
	}
	geladen = 2;
	gzm->messungEnde();
	if (log)
	{
		Text msg = "Reader: Zum laden benötigte Sekunden: ";
		msg += gzm->getSekunden();
		logNachricht(msg);
	}
	std::cout << "KSGS Reader: Zum laden benötigte Sekunden: " << gzm->getSekunden() << "\n";
	gzm->release();
	unlock();
	return 1;
}

void KSGScriptO::reset()
{
	lock();
	geladen = 0;
	variablen->leeren();
	funktionen->leeren();
	klassen->leeren();
	mausP->leeren();
	tastaturP->leeren();
	tickP->leeren();
	renderP->leeren();
	unlock();
}

void KSGScriptO::setCallbackParam(void* p)
{
	rParam = p;
}

void KSGScriptO::setCallbackFunktion(void(*funktion)(void*, RCArray< KSGSVariable >*, KSGSVariable**))
{
	rFunktion = funktion;
}

void KSGScriptO::setSchriftZ(Schrift* s)
{
	if (schrift)
		schrift->release();
	schrift = s;
}

void KSGScriptO::setBildschirmZ(Bildschirm* s)
{
	if (screen)
		screen->release();
	screen = s;
}

void KSGScriptO::doPublicMausEreignis(MausEreignis& me)
{
	if (geladen != 2)
		return;
	lock();
	me.mx -= pos.x;
	me.my -= pos.y;
	int anz = funktionen->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (funktionen->z(i)->getId() == mausId)
		{
			((KSGSMausEreignisKlasse*)mausP->z(0))->set(me);
			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(mausP->getThis()));
			KSGSVariable* ret = inst->startFunktion();
			if (ret)
			{
				me.verarbeitet |= ret->getBool();
				ret->release();
			}
			if (inst->isFunctionExecuting())
				inst->warteAufFunktion(INFINITE);
			inst->release();
			break;
		}
	}
	me.mx += pos.x;
	me.my += pos.y;
	unlock();
}

void KSGScriptO::doTastaturEreignis(TastaturEreignis& te)
{
	if (geladen != 2)
		return;
	lock();
	int anz = funktionen->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (funktionen->z(i)->getId() == tastaturId)
		{
			((KSGSTastaturEreignisKlasse*)tastaturP->z(0))->set(te);
			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(tastaturP->getThis()));
			KSGSVariable* ret = inst->startFunktion();
			if (ret)
			{
				te.verarbeitet |= ret->getBool();
				ret->release();
			}
			if (inst->isFunctionExecuting())
				inst->warteAufFunktion(INFINITE);
			inst->release();
			break;
		}
	}
	unlock();
}

bool KSGScriptO::tick(double zeit)
{
	if (geladen != 2)
		return 0;
	lock();
	int anz = funktionen->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (funktionen->z(i)->getId() == tickId)
		{
			((KSGSDoubleKlasse*)tickP->z(0))->set(zeit);
			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(tickP->getThis()));
			KSGSVariable* ret = inst->startFunktion();
			bool r = 0;
			if (ret)
			{
				r = ret->getBool();
				ret->release();
			}
			if (inst->isFunctionExecuting())
				inst->warteAufFunktion(INFINITE);
			inst->release();
			unlock();
			return r;
		}
	}
	unlock();
	return 0;
}

void KSGScriptO::render(Bild& zRObj)
{
	if (geladen != 2)
		return;
	lock();
	if (!zRObj.setDrawOptions(pos, gr))
	{
		unlock();
		return;
	}
	int anz = funktionen->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (funktionen->z(i)->getId() == renderId)
		{
			((KSGSBildKlasse*)renderP->z(0))->set(dynamic_cast<Bild*>(zRObj.getThis()));
			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(renderP->getThis()));
			KSGSVariable* ret = inst->startFunktion();
			if (ret)
				ret->release();
			if (inst->isFunctionExecuting())
				inst->warteAufFunktion(INFINITE);
			inst->release();
			break;
		}
	}
	zRObj.releaseDrawOptions();
	unlock();
}

KSGSVariable* KSGScriptO::startFunktion(int id, RCArray< KSGSVariable >* parameter)
{
	if (!funktionen || !funktionen->z(id) || funktionen->z(id)->getSichtbarkeit() != 0)
	{
		error(19, {}, this);
		parameter->release();
		return 0;
	}
	KSGSFunktionInstanz* inst = funktionen->z(id)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, parameter);
	KSGSVariable* ret = inst->startFunktion();
	inst->release();
	return ret;
}

KSGSVariable* KSGScriptO::erstellKlassenInstanz(int id)
{
	int anz = klassen->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (klassen->z(i) && klassen->z(i)->getId() == id)
			return klassen->z(i)->erstellInstanz(this);
	}
	error(2, {}, this);
	return 0;
}

void KSGScriptO::setVariable(int id, KSGSVariable* var)
{
	variablen->set(var, id);
}

Text* KSGScriptO::convertPfad(const char* pf)
{
	Text* ret = new Text(pf);
	ret->ersetzen('\\', '/');
	if (ret->getText()[0] == '/')
	{
		ret->remove(0);
		return ret;
	}
	ret->insert(0, wd->getText());
	return ret;
}

void KSGScriptO::setLog(TextFeld* log)
{
	lock();
	if (this->log)
		this->log->release();
	this->log = log;
	unlock();
}

void KSGScriptO::logNachricht(const  char* n)
{
	if (log)
	{
		lock();
		log->addZeile(n);
		unlock();
	}
}

// constant
KSGSVariable* KSGScriptO::callback(RCArray< KSGSVariable >* parameter) const
{
	if (!rFunktion)
	{
		parameter->release();
		return 0;
	}
	KSGSVariable* ret = 0;
	rFunktion(rParam, parameter, &ret);
	parameter->release();
	return ret;
}

Text* KSGScriptO::getScriptDateiPfad() const
{
	return dynamic_cast<Text*>(pfad->getThis());
}

Text* KSGScriptO::zScriptDateiPfad() const
{
	return pfad;
}

Schrift* KSGScriptO::getSchrift() const
{
	return schrift ? dynamic_cast<Schrift*>(schrift->getThis()) : 0;
}

Schrift* KSGScriptO::zSchrift() const
{
	return schrift;
}

Bildschirm* KSGScriptO::getBildschirm() const
{
	return screen ? dynamic_cast<Bildschirm*>(screen->getThis()) : 0;
}

Bildschirm* KSGScriptO::zBildschirm() const
{
	return screen;
}

int KSGScriptO::getScriptId() const
{
	return scrId;
}

bool KSGScriptO::istBeendet(int scrId) const
{
	return !geladen || this->scrId != scrId;
}

int KSGScriptO::getFunktionId(const char* name) const
{
	int anz = funktionen->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (funktionen->z(i)->hatName(name))
			return i;
	}
	return -1;
}

KSGSVariable* KSGScriptO::getVariable(int id) const
{
	if (!variablen || !variablen->z(id))
	{
		error(17, {}, (KSGScriptO*)this);
		return 0;
	}
	return variablen->get(id);
}