Stickman-World-Online-Client/StickmanWorldOnline/Aktionen.cpp

#include "Aktionen.h"
#include "Trigger.h"
#include "Spiel.h"


#define zParam( x )    zEvaluatedParam( x, zMemory, zPC )
#define getParam( x )  getEvaluatedParam( x, zMemory, zPC )
#define setReturn( x ) zMemory->setVar( "__return__", x )
#define zReturn        zMemory->zVariable( "__return__" )
#define getReturn      zMemory->getVariable( "__return__" )


Aktion::Aktion(AktionTyp typ, RCArray< Aktion >* subActions)
	: Variable(AKTION)
{
	this->subActions = subActions;
	for (int i = 0; i < subActions->getEintragAnzahl(); i++)
		erlaubteTypen.add(ALLE);
	this->typ = typ;
}

Aktion::~Aktion()
{
	subActions->release();
}

Variable* Aktion::zEvaluatedParam(int number, LocalMemory* zMemory, ProgramCounter* zPC)
{
	return zMemory->zVariable(zPC->getUniqueString() + "R" + number + "__");
}

Variable* Aktion::getEvaluatedParam(int number, LocalMemory* zMemory, ProgramCounter* zPC)
{
	return zMemory->getVariable(zPC->getUniqueString() + "R" + number + "__");
}

bool Aktion::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	if (waitCount > 0)
		return 0;
	zPC->stepIn();
	// evaluate parameters
	for (int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++)
	{
		if (!subActions->z(i)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
		{
			zPC->stepOut();
			return 0;
		}
		Variable* result = zReturn;
		if ((!result && erlaubteTypen.get(i) != NICHTS) || (result && result->getVariableTyp() != erlaubteTypen.get(i)))
		{
			zPC->stepOut();
			return 1;
		}
		if (result)
			zMemory->setVar(zPC->getUniqueString() + "R" + i + "__", dynamic_cast<Variable*>(result->getThis()));
		zPC->count();
		if (waitCount > 0)
		{
			zPC->stepOut();
			return 0;
		}
	}
	if (zPC->currentPosition() == subActions->getEintragAnzahl())
	{
		// evaluate result
		run(zSpiel, zEreignis, zMemory, zPC, waitCount);
		zPC->stepOut();
		return 1;
	}
	zPC->stepOut();
	return 0;
}

void Aktion::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{}

void Aktion::writeOptions(StreamWriter& dat)
{}

AktionTyp Aktion::getTyp() const
{
	return typ;
}

RCArray< Aktion >* Aktion::zSubActions() const
{
	return subActions;
}


KonstantNichts::KonstantNichts()
	: Aktion(KONSTANT_NICHTS, new RCArray< Aktion >())
{}

void KonstantNichts::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Variable(NICHTS));
}


KonstantInteger::KonstantInteger(int val)
	: Aktion(KONSTANT_INTEGER, new RCArray< Aktion >())
{
	this->value = val;
}

void KonstantInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(value));
}

void KonstantInteger::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&value, 4);
}


KonstantGegenstandTyp::KonstantGegenstandTyp(GegenstandTyp val)
	: Aktion(KONSTANT_GEGENSTAND_TYP, new RCArray< Aktion >())
{
	this->value = val;
}

void KonstantGegenstandTyp::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new GegenstandTypVar(value));
}

void KonstantGegenstandTyp::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&value, 4);
}


KonstantTaste::KonstantTaste(unsigned char val)
	: Aktion(KONSTANT_TASTE, new RCArray< Aktion >())
{
	this->value = val;
}

void KonstantTaste::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer((int)value, 1));
}

void KonstantTaste::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&value, 1);
}


KonstantBoolean::KonstantBoolean(bool val)
	: Aktion(KONSTANT_BOOLEAN, new RCArray< Aktion >())
{
	value = val;
}

void KonstantBoolean::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(value));
}

void KonstantBoolean::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&value, 1);
}


KonstantString::KonstantString(Text val)
	: Aktion(KONSTANT_STRING, new RCArray< Aktion >())
{
	value = val;
}

void KonstantString::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(value));
}

void KonstantString::writeOptions(StreamWriter& dat)
{
	char len = (char)value.getLength();
	dat.schreibe((char*)&len, 1);
	dat.schreibe(value, len);
}


KonstantFloat::KonstantFloat(float val)
	: Aktion(KONSTANT_FLOAT, new RCArray< Aktion >())
{
	value = val;
}

void KonstantFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(value));
}

void KonstantFloat::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&value, 4);
}


KonstantVariable::KonstantVariable(Text name)
	: Aktion(KONSTANT_VARIABLE, new RCArray< Aktion >())
{
	this->name = name;
}

void KonstantVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	if (zMemory->zVariable(name))
		setReturn(zMemory->getVariable(name));
	else if (zEreignis->zParameter(name))
		setReturn(zEreignis->getParameter(name));
	else if (zSpiel->zVariable(name))
		setReturn(zSpiel->getVariable(name));
	else
		setReturn(new Variable(NICHTS));
}

void KonstantVariable::writeOptions(StreamWriter& dat)
{
	char len = (char)name.getLength();
	dat.schreibe((char*)&len, 1);
	dat.schreibe(name, len);
}


Warten::Warten(RCArray< Aktion >* subActions)
	: Aktion(WARTEN, subActions)
{
	this->erlaubteTypen.add(FLOAT);
}

void Warten::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	waitCount += ((Float*)zParam(0))->getValue();
}


WennDannSonst::WennDannSonst(RCArray< Aktion >* subActions)
	: Aktion(WENN_DANN_SONST, subActions)
{}

bool WennDannSonst::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	zPC->stepIn();
	if (zPC->currentPosition() == 0)
	{
		bool finished = subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
		if (finished)
		{
			Variable* ret = zReturn;
			zPC->count();
			if (!isTrue(ret))
			{
				zPC->count();
				if (!subActions->z(2))
				{
					zPC->stepOut();
					return 1;
				}
			}
			else
			{
				if (!subActions->z(1))
				{
					zPC->stepOut();
					return 1;
				}
			}
		}
	}
	if (zPC->currentPosition() == 1 && waitCount <= 0)
	{
		bool finished = subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
		if (finished)
		{
			zPC->stepOut();
			return 1;
		}
	}
	if (zPC->currentPosition() == 2 && waitCount <= 0)
	{
		bool finished = subActions->z(2)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
		if (finished)
		{
			zPC->stepOut();
			return 1;
		}
	}
	zPC->stepOut();
	return 0;
}


SetVariable::SetVariable(Text name, RCArray< Aktion >* subActions)
	: Aktion(SET_VARIABLE, subActions)
{
	this->name = name;
}

void SetVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	if (zMemory->zVariable(name) || zEreignis->zParameter(name) || !zSpiel->zVariable(name))
		zMemory->setVar(name, getParam(0));
	else
		zSpiel->setVariable(name, getParam(0));
}

void SetVariable::writeOptions(StreamWriter& dat)
{
	char len = (char)name.getLength();
	dat.schreibe((char*)&len, 1);
	dat.schreibe(name, len);
}


TriggerAktion::TriggerAktion(RCArray< Aktion >* subActions)
	: Aktion(TRIGGER_AKTION, subActions)
{}

bool TriggerAktion::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	zPC->stepIn();
	if (zPC->currentPosition() == 0)
	{
		if (subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
		{
			Variable* t = zReturn;
			if (!t || t->getVariableTyp() != INTEGER)
			{
				zPC->stepOut();
				return 1;
			}
			zMemory->setVar(zPC->getUniqueString() + "R0__", dynamic_cast<Variable*>(t->getThis()));
			zPC->count();
		}
	}
	if (zPC->currentPosition() == 1 && waitCount <= 0)
	{
		if (subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
		{
			Variable* t = zReturn;
			if (!t || t->getVariableTyp() != TRIGGER)
			{
				zPC->stepOut();
				return 1;
			}
			int id = ((Integer*)zParam(0))->getValue();
			if (id >= ((Trigger*)t)->getAktionAnzahl())
			{
				zPC->stepOut();
				return 1;
			}
			zMemory->setVar(zPC->getUniqueString() + "R0__", ((Trigger*)t)->getAktion(id));
			zPC->count();
		}
	}
	if (zPC->currentPosition() == 2 && waitCount <= 0)
	{
		if (((Aktion*)zParam(0))->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
		{
			zPC->stepOut();
			return 1;
		}
	}
	zPC->stepOut();
	return 0;
}


SpielerNachricht::SpielerNachricht(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_NACHRICHT, subActions)
{
	erlaubteTypen.add(SPIELER);
	erlaubteTypen.add(STRING);
}

void SpielerNachricht::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	// this is handeld on client side directly (no need to send the message to the player)
}


DisplayText::DisplayText(RCArray< Aktion >* subActions)
	: Aktion(DISPLAY_TEXT, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(STRING);
}

void DisplayText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	// do nothing because the server does not need to show text
}


SpielPause::SpielPause(RCArray< Aktion >* subActions)
	: Aktion(SPIEL_PAUSE, subActions)
{
	erlaubteTypen.add(BOOLEAN);
}

void SpielPause::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	zSpiel->setPausiert(((Boolean*)zParam(0))->getValue());
}


SpielEnde::SpielEnde(RCArray< Aktion >* subActions)
	: Aktion(SPIEL_ENDE, subActions)
{}

void SpielEnde::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Variable* t = zParam(0);
	if (t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM)
		t = 0;
	zSpiel->setEnde((!t || t->getVariableTyp() == NICHTS) ? 0 : (Team*)t);
}


SpielerSetLevel::SpielerSetLevel(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_LEVEL, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetLevel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setLevel(((Integer*)zParam(0))->getValue(), zSpiel);
}


SpielerGiveItem::SpielerGiveItem(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_GIVE_ITEM, subActions)
{
	erlaubteTypen.add(GEGENSTAND_TYP);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(SPIELER);
}

void SpielerGiveItem::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(2))->addItem(((GegenstandTypVar*)zParam(0))->getValue(),
		((Integer*)zParam(1))->getValue(), zSpiel);
}


SpielerRemoveItem::SpielerRemoveItem(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_REMOVE_ITEM, subActions)
{
	erlaubteTypen.add(GEGENSTAND_TYP);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(SPIELER);
}

void SpielerRemoveItem::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(2))->removeItem(((GegenstandTypVar*)zParam(0))->getValue(),
		((Integer*)zParam(1))->getValue());
}


SpielerSetLeben::SpielerSetLeben(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_LEBEN, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setLeben(((Float*)zParam(0))->getValue());
}


SpielerSetMaxLeben::SpielerSetMaxLeben(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_LEBEN, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetMaxLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setMaxLeben(((Integer*)zParam(0))->getValue());
}


SpielerSetErfahrung::SpielerSetErfahrung(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_ERFAHRUNG, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setErfahrung(((Float*)zParam(0))->getValue(), zSpiel);
}


SpielerSetMaxErfahrung::SpielerSetMaxErfahrung(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_MAX_ERFAHRUNG, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetMaxErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setMaxErfahrung(((Integer*)zParam(0))->getValue());
}


SpielerSetTempo::SpielerSetTempo(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_TEMPO, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setLaufTempo(((Float*)zParam(0))->getValue());
}


SpielerSetWaffenTempo::SpielerSetWaffenTempo(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_GESCHOSS_TEMPO, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetWaffenTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setGeschossTempo(((Float*)zParam(0))->getValue());
}


SpielerSetArmor::SpielerSetArmor(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_ARMOR, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetArmor::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setArmor(((Float*)zParam(0))->getValue());
}


SpielerSetSchadenBonus::SpielerSetSchadenBonus(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_SCHADEN_BONUS, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetSchadenBonus::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setSchadenBonus(((Float*)zParam(0))->getValue());
}


SpielerSetLebensraub::SpielerSetLebensraub(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_LEBENSRAUB, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetLebensraub::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setLebensRaub(((Float*)zParam(0))->getValue());
}


SpielerSetLebensregeneration::SpielerSetLebensregeneration(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_LEBENSRAUB, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetLebensregeneration::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setLebensRegeneration(((Float*)zParam(0))->getValue());
}


SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(SPIELER);
}

void SpielerSetAbklingzeitverringerung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Spieler*)zParam(1))->setAbklingZeitVerringerung(((Float*)zParam(0))->getValue());
}


DropSetTime::DropSetTime(RCArray< Aktion >* subActions)
	: Aktion(DROP_SET_TIME, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(DROP);
}

void DropSetTime::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Drop*)zParam(1))->setTime(((Float*)zParam(0))->getValue());
}


DropSetMaxTime::DropSetMaxTime(RCArray< Aktion >* subActions)
	: Aktion(DROP_SET_MAX_TIME, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(DROP);
}

void DropSetMaxTime::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Drop*)zParam(1))->setMaxTime(((Integer*)zParam(0))->getValue());
}


DropSetArea::DropSetArea(RCArray< Aktion >* subActions)
	: Aktion(DROP_SET_AREA, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(DROP);
}

void DropSetArea::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Drop*)zParam(4))->setMinX(((Integer*)zParam(0))->getValue());
	((Drop*)zParam(4))->setMaxX(((Integer*)zParam(1))->getValue());
	((Drop*)zParam(4))->setMinY(((Integer*)zParam(2))->getValue());
	((Drop*)zParam(4))->setMaxY(((Integer*)zParam(3))->getValue());
}


DropDoDrop::DropDoDrop(RCArray< Aktion >* subActions)
	: Aktion(DROP_DO_DROP, subActions)
{
	erlaubteTypen.add(DROP);
}

void DropDoDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Drop*)zParam(0))->doDrop(zSpiel);
}


BariereBewegung::BariereBewegung(RCArray< Aktion >* subActions)
	: Aktion(BARIERE_BEWEGUNG, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void BariereBewegung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Bariere*)zParam(0))->startAutoVerschiebung(zSpiel);
}


BariereSetEingeschaltet::BariereSetEingeschaltet(RCArray< Aktion >* subActions)
	: Aktion(BARIERE_SET_EINGESCHALTET, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(DROP);
}

void BariereSetEingeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Bariere*)zParam(1))->setStyle(Bariere::Style::Aktiv, ((Boolean*)zParam(0))->getValue(), zSpiel);
}


GameObjektSetPosition::GameObjektSetPosition(RCArray< Aktion >* subActions)
	: Aktion(GAME_OBJEKT_SET_POSITION, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(GAME_OBJEKT);
}

void GameObjektSetPosition::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((GameObject*)zParam(2))->setX(((Float*)zParam(0))->getValue());
	((GameObject*)zParam(2))->setY(((Float*)zParam(1))->getValue());
}


GameObjektSetSize::GameObjektSetSize(RCArray< Aktion >* subActions)
	: Aktion(GAME_OBJEKT_SET_SIZE, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(GAME_OBJEKT);
}

void GameObjektSetSize::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((GameObject*)zParam(2))->setWidth(((Float*)zParam(0))->getValue());
	((GameObject*)zParam(2))->setHeight(((Float*)zParam(1))->getValue());
}


BariereSetTeam::BariereSetTeam(RCArray< Aktion >* subActions)
	: Aktion(BARIERE_SET_TEAM, subActions)
{
	erlaubteTypen.add(TEAM);
	erlaubteTypen.add(BARIERE);
}

void BariereSetTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Bariere*)zParam(1))->setTeam(((Team*)getParam(0)));
}


SchalterSetErlaubt::SchalterSetErlaubt(RCArray< Aktion >* subActions)
	: Aktion(SCHALTER_SET_ERLAUBT, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(SCHALTER);
}

void SchalterSetErlaubt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Schalter*)zParam(1))->setAktive(((Boolean*)zParam(0))->getValue());
}


SchalterAktivieren::SchalterAktivieren(RCArray< Aktion >* subActions)
	: Aktion(SCHALTER_AKTIVIEREN, subActions)
{
	erlaubteTypen.add(SCHALTER);
}

void SchalterAktivieren::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	zSpiel->activateShalter(((Schalter*)zParam(0))->getId());
}


TunnelSetZielPosition::TunnelSetZielPosition(RCArray< Aktion >* subActions)
	: Aktion(TUNNEL_SET_ZIEL_POSITION, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(TUNNEL);
}

void TunnelSetZielPosition::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Tunnel*)zParam(2))->setZielX(((Integer*)zParam(0))->getValue());
	((Tunnel*)zParam(2))->setZielY(((Integer*)zParam(1))->getValue());
}


TunnelSetErlaubt::TunnelSetErlaubt(RCArray< Aktion >* subActions)
	: Aktion(TUNNEL_SET_ERLAUBT, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(TUNNEL);
}

void TunnelSetErlaubt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Tunnel*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
}


UmlenkungSetRichtung::UmlenkungSetRichtung(RCArray< Aktion >* subActions)
	: Aktion(UMLENKUNG_SET_RICHTUNG, subActions)
{
	erlaubteTypen.add(RICHTUNG);
	erlaubteTypen.add(UMLENKUNG);
}

void UmlenkungSetRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Umlenkung*)zParam(1))->setRichtung(getRichtungFromString(((String*)zParam(0))->getValue()));
}


UmlenkungSetMaxAbk::UmlenkungSetMaxAbk(RCArray< Aktion >* subActions)
	: Aktion(UMLENKUNG_SET_MAX_ABK, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(UMLENKUNG);
}

void UmlenkungSetMaxAbk::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Umlenkung*)zParam(1))->setMaxAbklingzeit(((Integer*)zParam(0))->getValue());
}


UmlenkungSetEnabled::UmlenkungSetEnabled(RCArray< Aktion >* subActions)
	: Aktion(UMLENKUNG_SET_ERLAUBT, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(UMLENKUNG);
}

void UmlenkungSetEnabled::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Umlenkung*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
}


BaseSetTeam::BaseSetTeam(RCArray< Aktion >* subActions)
	: Aktion(BASE_SET_TEAM, subActions)
{
	erlaubteTypen.add(TEAM);
	erlaubteTypen.add(BASE);
}

void BaseSetTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Base*)zParam(1))->setTeam(((Team*)getParam(0)), zSpiel);
}


BaseStartTeamChange::BaseStartTeamChange(RCArray< Aktion >* subActions)
	: Aktion(BASE_START_TEAM_CHANGE, subActions)
{
	erlaubteTypen.add(TEAM);
	erlaubteTypen.add(BASE);
}

void BaseStartTeamChange::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Base*)zParam(1))->startChange(((Team*)getParam(0)));
}


TriggerRunStart::TriggerRunStart(RCArray< Aktion >* subActions)
	: Aktion(TRIGGER_RUN_START, subActions)
{
	erlaubteTypen.add(TRIGGER);
}

void TriggerRunStart::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	zSpiel->addTriggerRun(((Trigger*)zParam(0))->runTrigger(dynamic_cast<Ereignis*>(zEreignis->getThis()), zSpiel));
}


TriggerSetEnabled::TriggerSetEnabled(RCArray< Aktion >* subActions)
	: Aktion(TRIGGER_SET_ENABLED, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(TRIGGER);
}

void TriggerSetEnabled::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Trigger*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
}


TeamSetPunkte::TeamSetPunkte(RCArray< Aktion >* subActions)
	: Aktion(TEAM_SET_PUNKTE, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(TEAM);
}

void TeamSetPunkte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Team*)zParam(1))->setPunkte(((Integer*)zParam(0))->getValue());
}


TimerSetPause::TimerSetPause(RCArray< Aktion >* subActions)
	: Aktion(TIMER_SET_PAUSE, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(TIMER);
}

void TimerSetPause::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Timer*)zParam(1))->setPause(zSpiel, ((Boolean*)zParam(0))->getValue());
}


TimerStart::TimerStart(RCArray< Aktion >* subActions)
	: Aktion(TIMER_START, subActions)
{
	erlaubteTypen.add(TIMER);
}

void TimerStart::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Timer*)zParam(0))->start(zSpiel);
}


TimerSetZeit::TimerSetZeit(RCArray< Aktion >* subActions)
	: Aktion(TIMER_SET_ZEIT, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(TIMER);
}

void TimerSetZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Timer*)zParam(1))->setZeit(((Float*)zParam(0))->getValue());
}


TimerSetSichtbar::TimerSetSichtbar(RCArray< Aktion >* subActions)
	: Aktion(TIMER_SET_SICHTBAR, subActions)
{
	erlaubteTypen.add(BOOLEAN);
	erlaubteTypen.add(TIMER);
}

void TimerSetSichtbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Timer*)zParam(1))->setSichtbar(((Boolean*)zParam(0))->getValue());
}


GeschossNeu::GeschossNeu(RCArray< Aktion >* subActions)
	: Aktion(GESCHOSS_NEU, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(GESCHOSS_TYP);
	erlaubteTypen.add(RICHTUNG);
}

void GeschossNeu::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Geschoss* g = new Geschoss(zSpiel->zResources(), zSpiel->getNextId(), 0,
		getGeschossTypFromString(((String*)zParam(2))->getValue()),
		getRichtungFromString(((String*)zParam(3))->getValue()),
		((Integer*)zParam(0))->getValue(),
		((Integer*)zParam(1))->getValue(), 0);
	zSpiel->addGeschoss(dynamic_cast<Geschoss*>(g->getThis()));
	setReturn(g);
}


GeschossSetSpeed::GeschossSetSpeed(RCArray< Aktion >* subActions)
	: Aktion(GESCHOSS_SET_SPEED, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(GESCHOSS);
}

void GeschossSetSpeed::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Geschoss*)zParam(1))->setSpeed(((Float*)zParam(0))->getValue());
}


GeschossSetPlayer::GeschossSetPlayer(RCArray< Aktion >* subActions)
	: Aktion(GESCHOSS_SET_PLAYER, subActions)
{
	erlaubteTypen.add(SPIELER);
	erlaubteTypen.add(GESCHOSS);
}

void GeschossSetPlayer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Geschoss*)zParam(1))->setBesitzer(((Spieler*)getParam(0)));
}


GeschossSetRichtung::GeschossSetRichtung(RCArray< Aktion >* subActions)
	: Aktion(GESCHOSS_SET_RICHTUNG, subActions)
{
	erlaubteTypen.add(RICHTUNG);
	erlaubteTypen.add(GESCHOSS);
}

void GeschossSetRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Geschoss*)zParam(1))->setRichtung(getRichtungFromString(((String*)zParam(0))->getValue()));
}


GeschossSetType::GeschossSetType(RCArray< Aktion >* subActions)
	: Aktion(GESCHOSS_SET_TYPE, subActions)
{
	erlaubteTypen.add(GESCHOSS_TYP);
	erlaubteTypen.add(GESCHOSS);
}

void GeschossSetType::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Geschoss*)zParam(1))->setTyp(getGeschossTypFromString(((String*)zParam(0))->getValue()));
}


TriggerZufall::TriggerZufall()
	: Aktion(TRIGGER_ZUFALL, new RCArray< Aktion >())
{}

void TriggerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomTrigger());
}


TriggerLastRunned::TriggerLastRunned()
	: Aktion(TRIGGER_LAST_RUNNED, new RCArray< Aktion >())
{}

void TriggerLastRunned::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getLastRunnedTrigger());
}


BariereZufall::BariereZufall()
	: Aktion(BARIERE_ZUFALL, new RCArray< Aktion >())
{}

void BariereZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomBariere());
}


BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
	: Aktion(BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >())
{}

void BariereZuletztEingeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getZuletztEingeschalteteBariere());
}


BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
	: Aktion(BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >())
{}

void BariereZuletztAusgeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getZuletztAusgeschalteteBariere());
}


BariereZuletztBewegt::BariereZuletztBewegt()
	: Aktion(BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >())
{}

void BariereZuletztBewegt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getZuletztBewegteBariere());
}


BaseZufall::BaseZufall()
	: Aktion(BASE_ZUFALL, new RCArray< Aktion >())
{}

void BaseZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomBase());
}


BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
	: Aktion(BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >())
{}

void BaseZuletztBesitzerGewechselt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getLastTeamChangedBase());
}


DropZufall::DropZufall()
	: Aktion(DROP_ZUFALL, new RCArray< Aktion >())
{}

void DropZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomDrop());
}


DropZuletztGedropt::DropZuletztGedropt()
	: Aktion(DROP_ZULETZT_GEDROPT, new RCArray< Aktion >())
{}

void DropZuletztGedropt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getLastDrop());
}


IntegerRechnen::IntegerRechnen(RCArray< Aktion >* subActions, Operator op)
	: Aktion(INTEGER_RECHNEN, subActions),
	op()
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
}

void IntegerRechnen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Integer* l = (Integer*)zParam(0);
	Integer* r = (Integer*)zParam(1);
	switch (op)
	{
	case PLUS:
		setReturn(new Integer(l->getValue() + r->getValue()));
		break;
	case MINUS:
		setReturn(new Integer(l->getValue() - r->getValue()));
		break;
	case MAHL:
		setReturn(new Integer(l->getValue() * r->getValue()));
		break;
	case GETEILT:
		setReturn(new Integer(l->getValue() / r->getValue()));
		break;
	case HOCH:
		setReturn(new Integer((int)pow(l->getValue(), r->getValue())));
		break;
	case WURZEL:
		setReturn(new Integer((int)pow(l->getValue(), 1.0 / r->getValue())));
		break;
	case BIT_ODER:
		setReturn(new Integer(l->getValue() | r->getValue()));
		break;
	case BIT_UND:
		setReturn(new Integer(l->getValue() & r->getValue()));
		break;
	case BIT_XOR:
		setReturn(new Integer(l->getValue() ^ r->getValue()));
		break;
	case BIT_FLIP:
		setReturn(new Integer(~l->getValue()));
		break;
	case BIT_SHIFT_LEFT:
		setReturn(new Integer(l->getValue() << r->getValue()));
		break;
	case BIT_SHIFT_RIGHT:
		setReturn(new Integer(l->getValue() >> r->getValue()));
		break;
	case INVERT_SIGN:
		setReturn(new Integer(-l->getValue()));
		break;
	case PLUS_PLUS_LEFT:
		l->setValue(l->getValue() + 1);
		setReturn(new Integer(l->getValue()));
		break;
	case PLUS_PLUS_RIGHT:
	{
		int tmp = l->getValue();
		l->setValue(l->getValue() + 1);
		setReturn(new Integer(tmp));
		break;
	}
	case MINUS_MINUS_LEFT:
		l->setValue(l->getValue() - 1);
		setReturn(new Integer(l->getValue()));
		break;
	case MINUS_MINUS_RIGHT:
	{
		int tmp = l->getValue();
		l->setValue(l->getValue() - 1);
		setReturn(new Integer(tmp));
		break;
	}
	case LOGARITHM:
		setReturn(new Integer((int)(log(l->getValue()) / log(r->getValue()))));
		break;
	case MODULO:
		setReturn(new Integer(l->getValue() % r->getValue()));
		break;
	default:
		break;
	}
}

void IntegerRechnen::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&this->op, 1);
}


IntegerZufall::IntegerZufall(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_ZUFALL, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
}

void IntegerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	int mi = ((Integer*)zParam(0))->getValue();
	int ma = ((Integer*)zParam(1))->getValue();
	setReturn(new Integer((int)(zSpiel->getRand() * ((double)ma - mi) + mi)));
}


IntegerAusText::IntegerAusText(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_AUS_TEXT, subActions)
{
	erlaubteTypen.add(STRING);
}

void IntegerAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer((int)((String*)zParam(0))->getValue()));
}


FloatXVonGameObjekt::FloatXVonGameObjekt(RCArray< Aktion >* subActions)
	: Aktion(FLOAT_X_VON_GAME_OBJEKT, subActions)
{
	erlaubteTypen.add(GAME_OBJEKT);
}

void FloatXVonGameObjekt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((GameObject*)zParam(0))->getX()));
}


FloatYVonGameObjekt::FloatYVonGameObjekt(RCArray< Aktion >* subActions)
	: Aktion(FLOAT_Y_VON_GAME_OBJEKT, subActions)
{
	erlaubteTypen.add(GAME_OBJEKT);
}

void FloatYVonGameObjekt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((GameObject*)zParam(0))->getY()));
}


IntegerXVonTunnelZiel::IntegerXVonTunnelZiel(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_X_VON_TUNNEL_ZIEL, subActions)
{
	erlaubteTypen.add(TUNNEL);
}

void IntegerXVonTunnelZiel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Tunnel*)zParam(0))->getZielX()));
}


IntegerYVonTunnelZiel::IntegerYVonTunnelZiel(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_Y_VON_TUNNEL_ZIEL, subActions)
{
	erlaubteTypen.add(TUNNEL);
}

void IntegerYVonTunnelZiel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Tunnel*)zParam(0))->getZielY()));
}


IntegerMinXVonDrop::IntegerMinXVonDrop(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_MIN_X_VON_DROP, subActions)
{
	erlaubteTypen.add(DROP);
}

void IntegerMinXVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Drop*)zParam(0))->getMinX()));
}


IntegerMinYVonDrop::IntegerMinYVonDrop(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_MIN_Y_VON_DROP, subActions)
{
	erlaubteTypen.add(DROP);
}

void IntegerMinYVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Drop*)zParam(0))->getMinY()));
}


IntegerMaxXVonDrop::IntegerMaxXVonDrop(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_MAX_X_VON_DROP, subActions)
{
	erlaubteTypen.add(DROP);
}

void IntegerMaxXVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Drop*)zParam(0))->getMaxX()));
}


IntegerMaxYVonDrop::IntegerMaxYVonDrop(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_MAX_Y_VON_DROP, subActions)
{
	erlaubteTypen.add(DROP);
}

void IntegerMaxYVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Drop*)zParam(0))->getMaxY()));
}


IntegerSpielerLevel::IntegerSpielerLevel(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_SPIELER_LEVEL, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerLevel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getLevel()));
}


FloatSpielerLeben::FloatSpielerLeben(RCArray< Aktion >* subActions)
	: Aktion(FLOAT_SPIELER_LEBEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getLeben()));
}

bool isBinary(Operator op)
{
	return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
		op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
}


IntegerSpielerMaxLeben::IntegerSpielerMaxLeben(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_MAX_LEBEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerMaxLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getMaxLeben()));
}


FloatSpielerErfahrung::FloatSpielerErfahrung(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_ERFAHRUNG, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getErfahrung()));
}


IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_MAX_ERFAHRUNG, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerMaxErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getMaxErfahrung()));
}


FloatSpielerTempo::FloatSpielerTempo(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_TEMPO, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getLaufTempo()));
}


FloatSpielerGeschossTempo::FloatSpielerGeschossTempo(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_GESCHOSS_TEMPO, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerGeschossTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getGeschossTempo()));
}


FloatSpielerArmor::FloatSpielerArmor(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_ARMOR, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerArmor::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getArmor()));
}


FloatSpielerSchadenBonus::FloatSpielerSchadenBonus(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_SCHADEN_BONUS, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerSchadenBonus::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getSchadenBonus()));
}


FloatSpielerLebensraub::FloatSpielerLebensraub(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_LEBENSRAUB, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerLebensraub::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getLebensRaub()));
}


FloatSpielerLebensregeneration::FloatSpielerLebensregeneration(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_LEBENSREGENERATION, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerLebensregeneration::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getLebensRegenneration()));
}


FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerAbklingzeitVerringerung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getAbklingZeitVerringerung()));
}


IntegerSpielerTode::IntegerSpielerTode(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_TODE, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerTode::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getTode()));
}


IntegerSpielerKills::IntegerSpielerKills(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_KILLS, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerKills::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getKills()));
}


IntegerSpielerTreffer::IntegerSpielerTreffer(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_TREFFER, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerTreffer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getTreffer()));
}


IntegerSpielerGetroffen::IntegerSpielerGetroffen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_TREFFER, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getGetroffen()));
}


FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerErlittenerSchaden::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getErlittenerSchaden()));
}


FloatSpielerSchaden::FloatSpielerSchaden(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerSchaden::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getGemachterSchaden()));
}


FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_SPIELER_GEHEILTES_LEBEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void FloatSpielerGeheiltesLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Spieler*)zParam(0))->getGeheiltesLeben()));
}


IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerItemsAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getItemsAufgehoben()));
}


IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_ITEMS_VERWENDET, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerItemsVerwendet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getItemsVerwendet()));
}


IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerItemsInInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getItemsInInventory()));
}


IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions)
{
	erlaubteTypen.add(GEGENSTAND_TYP);
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerItemsTypeInInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(1))->getItemsInInventory(((GegenstandTypVar*)zParam(0))->getValue())));
}


IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_TUNNEL_BENUTZT, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getTunnelBenutzt()));
}


IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerSchalterAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getSchalterAktiviert()));
}


IntegerSpielerGeschossen::IntegerSpielerGeschossen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SPIELER_GESCHOSSEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void IntegerSpielerGeschossen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Spieler*)zParam(0))->getGeschossen()));
}


FloatDropZeit::FloatDropZeit(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_DROP_ZEIT, subActions)
{
	erlaubteTypen.add(DROP);
}

void FloatDropZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Drop*)zParam(0))->getZeit()));
}


IntegerDropMaxZeit::IntegerDropMaxZeit(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_DROP_MAX_ZEIT, subActions)
{
	erlaubteTypen.add(DROP);
}

void IntegerDropMaxZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Drop*)zParam(0))->getMaxTime()));
}


FloatGameObjektBreite::FloatGameObjektBreite(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_GAME_OBJEKT_BREITE, subActions)
{
	erlaubteTypen.add(GAME_OBJEKT);
}

void FloatGameObjektBreite::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((GameObject*)zParam(0))->getWidth()));
}


FloatGameObjektHeight::FloatGameObjektHeight(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_GAME_OBJEKT_HEIGHT, subActions)
{
	erlaubteTypen.add(GAME_OBJEKT);
}

void FloatGameObjektHeight::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((GameObject*)zParam(0))->getHeight()));
}


IntegerBariereVerschiebungen::IntegerBariereVerschiebungen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_BARIERE_VERSCHIEBUNGEN, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void IntegerBariereVerschiebungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Bariere*)zParam(0))->getVerschiebungAnzahl()));
}


IntegerBariereSchaltungen::IntegerBariereSchaltungen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_BARIERE_SCHALTUNGEN, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void IntegerBariereSchaltungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Bariere*)zParam(0))->getSchaltungAnzahl()));
}


IntegerSchalterAktivierungen::IntegerSchalterAktivierungen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_SCHALTER_AKTIVIERUNGEN, subActions)
{
	erlaubteTypen.add(SCHALTER);
}

void IntegerSchalterAktivierungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Schalter*)zParam(0))->getAnzahlAktivierungen()));
}


IntegerTunnelBenutzungen::IntegerTunnelBenutzungen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TUNNEL_BENUTZUNGEN, subActions)
{
	erlaubteTypen.add(TUNNEL);
}

void IntegerTunnelBenutzungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Tunnel*)zParam(0))->getBenutzungen()));
}


IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_UMLENKUNG_BENUTZUNGEN, subActions)
{
	erlaubteTypen.add(UMLENKUNG);
}

void IntegerUmlenkungBenutzungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Umlenkung*)zParam(0))->getBenutzungen()));
}


IntegerTeamPunkte::IntegerTeamPunkte(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TEAM_PUNKTE, subActions)
{
	erlaubteTypen.add(TEAM);
}

void IntegerTeamPunkte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Team*)zParam(0))->getPunkte()));
}


IntegerTeamKills::IntegerTeamKills(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TEAM_KILLS, subActions)
{
	erlaubteTypen.add(TEAM);
}

void IntegerTeamKills::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Team*)zParam(0))->getKills()));
}


IntegerTeamTode::IntegerTeamTode(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TEAM_TODE, subActions)
{
	erlaubteTypen.add(TEAM);
}

void IntegerTeamTode::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Team*)zParam(0))->getTode()));
}


FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions)
{
	erlaubteTypen.add(TEAM);
}

void FloatTeamWiederbelegungszeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Team*)zParam(0))->getMaxWiederbelebungsZeit()));
}


IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TEAM_SPIELERANZAHL, subActions)
{
	erlaubteTypen.add(TEAM);
}

void IntegerTeamSpieleranzahl::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Team*)zParam(0))->getSpielerAnzahl()));
}


FloatTimerAktuelleZeit::FloatTimerAktuelleZeit(RCArray<Aktion>* subActions)
	: Aktion(FLOAT_TIMER_AKTUELLE_ZEIT, subActions)
{
	erlaubteTypen.add(TIMER);
}

void FloatTimerAktuelleZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float(((Timer*)zParam(0))->getTimeLeft()));
}


IntegerTimerMaxZeit::IntegerTimerMaxZeit(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TIMER_MAX_ZEIT, subActions)
{
	erlaubteTypen.add(TIMER);
}

void IntegerTimerMaxZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Timer*)zParam(0))->getMaxTime()));
}


IntegerTriggerRunns::IntegerTriggerRunns(RCArray<Aktion>* subActions)
	: Aktion(INTEGER_TRIGGER_RUNNS, subActions)
{
	erlaubteTypen.add(TRIGGER);
}

void IntegerTriggerRunns::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer(((Trigger*)zParam(0))->getRuns()));
}


ItemSpielerInventar::ItemSpielerInventar(RCArray<Aktion>* subActions)
	: Aktion(ITEM_SPIELER_INVENTAR, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(SPIELER);
}

void ItemSpielerInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new GegenstandTypVar((((Spieler*)zParam(1))->getInventorySlot(((Integer*)zParam(0))->getValue()))));
}


ItemZuletztAufgehoben::ItemZuletztAufgehoben()
	: Aktion(ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >())
{}

void ItemZuletztAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new GegenstandTypVar(zSpiel->getItemZuletztAufgehoben()));
}


ItemZuletztAktiviert::ItemZuletztAktiviert()
	: Aktion(ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >())
{}

void ItemZuletztAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new GegenstandTypVar(zSpiel->getItemZuletztAktiviert()));
}


ItemZuletztGedropt::ItemZuletztGedropt()
	: Aktion(ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >())
{}

void ItemZuletztGedropt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new GegenstandTypVar(zSpiel->getItemZuletztGedropt()));
}


ItemZufall::ItemZufall()
	: Aktion(ITEM_ZUFALL, new RCArray< Aktion >())
{}

void ItemZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new GegenstandTypVar((GegenstandTyp)(int)(zSpiel->getRand() * ITEMANZAHL)));
}


GeschossZufall::GeschossZufall()
	: Aktion(GESCHOSS_ZUFALL, new RCArray< Aktion >())
{}

void GeschossZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomGeschoss());
}


GeschossZuletztAbgefeuert::GeschossZuletztAbgefeuert()
	: Aktion(GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >())
{}

void GeschossZuletztAbgefeuert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getGeschossZuletztAbgefeuert());
}


GeschossZuletztUmgelenkt::GeschossZuletztUmgelenkt()
	: Aktion(GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >())
{}

void GeschossZuletztUmgelenkt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getGeschossZuletztUmgelenkt());
}


GeschossZuletztBarjereGetroffen::GeschossZuletztBarjereGetroffen()
	: Aktion(GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >())
{}

void GeschossZuletztBarjereGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getGeschossZuletztBariereGetroffen());
}


GeschossZuletztTunnelBenutzt::GeschossZuletztTunnelBenutzt()
	: Aktion(GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >())
{}

void GeschossZuletztTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getGeschossZuletztTunnelBenutzt());
}


GeschossZuletztGeschossGetroffen::GeschossZuletztGeschossGetroffen()
	: Aktion(GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >())
{}

void GeschossZuletztGeschossGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getGeschossZuletztGeschossGetroffen());
}


RichtungZufall::RichtungZufall()
	: Aktion(RICHTUNG_ZUFALL, new RCArray< Aktion >())
{}

void RichtungZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String((Richtung)(int)(zSpiel->getRand() * RICHTUNG_ANZAHL)));
}


RichtungVonUmlenkung::RichtungVonUmlenkung(RCArray< Aktion >* subActions)
	: Aktion(RICHTUNG_VON_UMLENKUNG, subActions)
{
	erlaubteTypen.add(UMLENKUNG);
}

void RichtungVonUmlenkung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((Umlenkung*)zParam(0))->getRichtung()));
}


RichtungVonGeschoss::RichtungVonGeschoss(RCArray< Aktion >* subActions)
	: Aktion(RICHTUNG_VON_GESCHOSS, subActions)
{
	erlaubteTypen.add(GESCHOSS);
}

void RichtungVonGeschoss::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((Geschoss*)zParam(0))->getRichtung()));
}


SchalterZufall::SchalterZufall()
	: Aktion(SCHALTER_ZUFALL, new RCArray< Aktion >())
{}

void SchalterZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomSchalter());
}


SchalterZuletztAktiviert::SchalterZuletztAktiviert()
	: Aktion(SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >())
{}

void SchalterZuletztAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSchalterZuletztAktiviert());
}


SpielerZufall::SpielerZufall()
	: Aktion(SPIELER_ZUFALL, new RCArray< Aktion >())
{}

void SpielerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomSpieler());
}


SpielerZufallAusTeam::SpielerZufallAusTeam(RCArray< Aktion >* subActions)
	: Aktion(SPIELER_ZUFALL_AUS_TEAM, subActions)
{
	erlaubteTypen.add(TEAM);
}

void SpielerZufallAusTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomSpieler((Team*)zParam(0)));
}


SpielerZuletztSchadenGemacht::SpielerZuletztSchadenGemacht()
	: Aktion(SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >())
{}

void SpielerZuletztSchadenGemacht::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztSchadenGemacht());
}


SpielerZuletztSchadenGenommen::SpielerZuletztSchadenGenommen()
	: Aktion(SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >())
{}

void SpielerZuletztSchadenGenommen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztSchadenGenommen());
}


SpielerZuletztGeheilt::SpielerZuletztGeheilt()
	: Aktion(SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >())
{}

void SpielerZuletztGeheilt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztGeheilt());
}


SpielerZuletztLevelUp::SpielerZuletztLevelUp()
	: Aktion(SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >())
{}

void SpielerZuletztLevelUp::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztLevelUp());
}


SpielerZuletztErfahrungBekommen::SpielerZuletztErfahrungBekommen()
	: Aktion(SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >())
{}

void SpielerZuletztErfahrungBekommen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztErfahrungBekommen());
}


SpielerZuletztGegenstandAktiviert::SpielerZuletztGegenstandAktiviert()
	: Aktion(SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >())
{}

void SpielerZuletztGegenstandAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztGegenstandAktiviert());
}


SpielerZuletztGegenstandAufgehoben::SpielerZuletztGegenstandAufgehoben()
	: Aktion(SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >())
{}

void SpielerZuletztGegenstandAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztGegenstandAufgehoben());
}


SpielerZuletztSchalterAktiviert::SpielerZuletztSchalterAktiviert()
	: Aktion(SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >())
{}

void SpielerZuletztSchalterAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztSchalterAktiviert());
}


SpielerZuletztTunnelBenutzt::SpielerZuletztTunnelBenutzt()
	: Aktion(SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >())
{}

void SpielerZuletztTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztTunnelBenutzt());
}


SpielerZuletztGestorben::SpielerZuletztGestorben()
	: Aktion(SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >())
{}

void SpielerZuletztGestorben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztGestorben());
}


SpielerZuletztWiederbelebent::SpielerZuletztWiederbelebent()
	: Aktion(SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >())
{}

void SpielerZuletztWiederbelebent::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztWiederbelebt());
}


SpielerZuletztGeschossGeschossen::SpielerZuletztGeschossGeschossen()
	: Aktion(SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >())
{}

void SpielerZuletztGeschossGeschossen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getSpielerZuletztGeschossen());
}


TextConcat::TextConcat(RCArray< Aktion >* subActions)
	: Aktion(TEXT_CONCAT, subActions)
{
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(STRING);
}

void TextConcat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	String* p1 = (String*)zParam(0);
	String* p2 = (String*)zParam(1);
	String* res = new String(p1->getValue().operator+(p2->getValue().getText()));
	setReturn(res);
}


TextAusInteger::TextAusInteger(RCArray< Aktion >* subActions)
	: Aktion(TEXT_AUS_INTEGER, subActions)
{
	erlaubteTypen.add(INTEGER);
}

void TextAusInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(Text(((Integer*)zParam(0))->getValue())));
}


TextAusRichtung::TextAusRichtung(RCArray< Aktion >* subActions)
	: Aktion(TEXT_AUS_RICHTUNG, subActions)
{
	erlaubteTypen.add(RICHTUNG);
}

void TextAusRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((String*)zParam(0))->getValue()));
}


TextAusBoolean::TextAusBoolean(RCArray< Aktion >* subActions)
	: Aktion(TEXT_AUS_BOOLEAN, subActions)
{
	erlaubteTypen.add(BOOLEAN);
}

void TextAusBoolean::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((Boolean*)zParam(0))->getValue() ? "true" : "false"));
}


TextSpielerName::TextSpielerName(RCArray< Aktion >* subActions)
	: Aktion(TEXT_SPIELER_NAME, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void TextSpielerName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((Spieler*)zParam(0))->getName()));
}


TextItemName::TextItemName(RCArray< Aktion >* subActions)
	: Aktion(TEXT_ITEM_NAME, subActions)
{
	erlaubteTypen.add(GEGENSTAND_TYP);
}

void TextItemName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	switch (((GegenstandTypVar*)zParam(0))->getValue())
	{
	case PFEIL:
		setReturn(new String("PFEIL"));
		break;
	case LEBEN:
		setReturn(new String("LEBEN"));
		break;
	case SCHILD:
		setReturn(new String("SCHILD"));
		break;
	case SCHUH:
		setReturn(new String("SCHUH"));
		break;
	case GEIST:
		setReturn(new String("GEIST"));
		break;
	case KUGEL:
		setReturn(new String("KUGEL"));
		break;
	case ROLLE:
		setReturn(new String("ROLLE"));
		break;
	case STURM:
		setReturn(new String("STURM"));
		break;
	case DRACHENAUGE:
		setReturn(new String("DRACHENAUGE"));
		break;
	case FEUERBALL:
		setReturn(new String("FEUERBALL"));
		break;
	case ENTERHAKEN:
		setReturn(new String("ENTERHAKEN"));
		break;
	case MINE:
		setReturn(new String("MINE"));
		break;
	case RWEISHEIT:
		setReturn(new String("RWEISHEIT"));
		break;
	case RSTRENGTH:
		setReturn(new String("RSTRENGTH"));
		break;
	case RBOSHEIT:
		setReturn(new String("RBOSHEIT"));
		break;
	case RLEBEN:
		setReturn(new String("RLEBEN"));
		break;
	case RTEMPO:
		setReturn(new String("RTEMPO"));
		break;
	default:
		setReturn(new String("NICHTS"));
		break;
	}
}


TextTriggerName::TextTriggerName(RCArray< Aktion >* subActions)
	: Aktion(TEXT_TRIGGER_NAME, subActions)
{
	erlaubteTypen.add(TRIGGER);
}

void TextTriggerName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((Trigger*)zParam(0))->getName()));
}


TextTeilVonText::TextTeilVonText(RCArray< Aktion >* subActions)
	: Aktion(TEXT_TEIL_VON_TEXT, subActions)
{
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(INTEGER);
	erlaubteTypen.add(STRING);
}

void TextTeilVonText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Text* txt = ((String*)zParam(2))->getValue().getTeilText(((Integer*)zParam(0))->getValue(), ((Integer*)zParam(1))->getValue());
	setReturn(new String(txt->getText()));
	txt->release();
}


TeamZufall::TeamZufall()
	: Aktion(TEAM_ZUFALL, new RCArray< Aktion >())
{}

void TeamZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomTeam());
}


TeamVonSpieler::TeamVonSpieler(RCArray< Aktion >* subActions)
	: Aktion(TEAM_VON_SPIELER, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void TeamVonSpieler::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(((Spieler*)zParam(0))->getTeam());
}


TeamVonBariere::TeamVonBariere(RCArray< Aktion >* subActions)
	: Aktion(TEAM_VON_BARIERE, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void TeamVonBariere::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(((Bariere*)zParam(0))->getTeam());
}


TimerZufall::TimerZufall()
	: Aktion(TIMER_ZUFALL, new RCArray< Aktion >())
{}

void TimerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomTimer());
}


TimerZuletztAbgelaufen::TimerZuletztAbgelaufen()
	: Aktion(TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >())
{}

void TimerZuletztAbgelaufen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getTimerZuletztAbgelaufen());
}


TimerZuletztGestartet::TimerZuletztGestartet()
	: Aktion(TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >())
{}

void TimerZuletztGestartet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getTimerZuletztGestartet());
}


TimerZuletztPausiert::TimerZuletztPausiert()
	: Aktion(TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >())
{}

void TimerZuletztPausiert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getTimerZuletztPausiert());
}


TimerZuletztFortgesetzt::TimerZuletztFortgesetzt()
	: Aktion(TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >())
{}

void TimerZuletztFortgesetzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getTimerZuletztFortgesetzt());
}


TunnelZufall::TunnelZufall()
	: Aktion(TUNNEL_ZUFALL, new RCArray< Aktion >())
{}

void TunnelZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomTunnel());
}


TunnelZuletztBenutzt::TunnelZuletztBenutzt()
	: Aktion(TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >())
{}

void TunnelZuletztBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getTunnelZuletztBenutzt());
}


UmlenkungZufall::UmlenkungZufall()
	: Aktion(UMLENKUNG_ZUFALL, new RCArray< Aktion >())
{}

void UmlenkungZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRandomUmlenkung());
}


UmlenkungZuletztBenutzt::UmlenkungZuletztBenutzt()
	: Aktion(UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >())
{}

void UmlenkungZuletztBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getUmlenkungZuletztBenutzt());
}


BooleanZufall::BooleanZufall()
	: Aktion(BOOLEAN_ZUFALL, new RCArray< Aktion >())
{}

void BooleanZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getRand() < 0.5 ? new Boolean(false) : new Boolean(true));
}


BooleanSpielPausiert::BooleanSpielPausiert()
	: Aktion(BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >())
{}

void BooleanSpielPausiert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(zSpiel->istPausiert()));
}


BooleanSpielerAmLeben::BooleanSpielerAmLeben(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_SPIELER_AM_LEBEN, subActions)
{
	erlaubteTypen.add(SPIELER);
}

void BooleanSpielerAmLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Spieler*)zParam(0))->istAmLeben()));
}


BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions)
{
	erlaubteTypen.add(GEGENSTAND_TYP);
	erlaubteTypen.add(SPIELER);
}

void BooleanSpielerHatGegenstand::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Spieler*)zParam(1))->getItemsInInventory(((GegenstandTypVar*)zParam(0))->getValue()) != 0));
}


BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions)
{
	erlaubteTypen.add(RICHTUNG);
	erlaubteTypen.add(SPIELER);
}

void BooleanSpielerIstVerwundbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Spieler*)zParam(1))->isVerwundbar(getRichtungFromString(((String*)zParam(0))->getValue()))));
}


BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions)
{
	erlaubteTypen.add(GEGENSTAND_TYP);
	erlaubteTypen.add(SPIELER);
}

void BooleanSpielerKannItemBenutzen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Spieler*)zParam(1))->istGegenstandErlaubt(((GegenstandTypVar*)zParam(0))->getValue())));
}


BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_UMLENKUNG_HAT_ABK, subActions)
{
	erlaubteTypen.add(UMLENKUNG);
}

void BooleanUmlenkungHatAbk::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Umlenkung*)zParam(0))->hatAbklingzeit()));
}


BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_UMLENKUNG_IST_DREHEND, subActions)
{
	erlaubteTypen.add(UMLENKUNG);
}

void BooleanUmlenkungIstDrehend::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Umlenkung*)zParam(0))->istDrehend()));
}


BooleanBariereBewegtSich::BooleanBariereBewegtSich(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_BARIERE_BEWEGT_SICH, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void BooleanBariereBewegtSich::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::InVerschiebung)));
}


BooleanBariereIstSchaltend::BooleanBariereIstSchaltend(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_BARIERE_IST_SCHALTEND, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void BooleanBariereIstSchaltend::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::AutoSchaltung)));
}


BooleanBariereIstAktiv::BooleanBariereIstAktiv(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_BARIERE_IST_AKTIV, subActions)
{
	erlaubteTypen.add(BARIERE);
}

void BooleanBariereIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::Aktiv)));
}


BooleanSchalterIstAktiv::BooleanSchalterIstAktiv(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_SCHALTER_IST_AKTIV, subActions)
{
	erlaubteTypen.add(SCHALTER);
}

void BooleanSchalterIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Schalter*)zParam(0))->isAktive()));
}


BooleanTunnelIstAktiv::BooleanTunnelIstAktiv(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_TUNNEL_IST_AKTIV, subActions)
{
	erlaubteTypen.add(TUNNEL);
}

void BooleanTunnelIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Tunnel*)zParam(0))->istAktiv()));
}


BooleanBaseIstNeutral::BooleanBaseIstNeutral(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_BASE_IST_NEUTRAL, subActions)
{
	erlaubteTypen.add(BASE);
}

void BooleanBaseIstNeutral::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Base*)zParam(0))->zTeam() == 0));
}


BooleanTimerIsRunning::BooleanTimerIsRunning(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_TIMER_IS_RUNNING, subActions)
{
	erlaubteTypen.add(TIMER);
}

void BooleanTimerIsRunning::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Timer*)zParam(0))->isRunning()));
}


BooleanTimerIstSichtbar::BooleanTimerIstSichtbar(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_TIMER_IST_SICHTBAR, subActions)
{
	erlaubteTypen.add(TIMER);
}

void BooleanTimerIstSichtbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Timer*)zParam(0))->istSichtbar()));
}


BooleanAusText::BooleanAusText(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_AUS_TEXT, subActions)
{
	erlaubteTypen.add(STRING);
}

void BooleanAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((String*)zParam(0))->getValue().istGleich("true")));
}


BooleanTriggerIstAktiv::BooleanTriggerIstAktiv(RCArray< Aktion >* subActions)
	: Aktion(BOOLEAN_TRIGGER_IST_AKTIV, subActions)
{
	erlaubteTypen.add(TRIGGER);
}

void BooleanTriggerIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Boolean(((Trigger*)zParam(0))->istAktiv()));
}


BooleanRechnung::BooleanRechnung(RCArray< Aktion >* subActions, Operator op)
	: Aktion(BOOLEAN_RECHNUNG, subActions)
{
	this->op = op;
}

void BooleanRechnung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	if (op == UND || op == ODER)
	{
		if (zParam(0)->getVariableTyp() != BOOLEAN || zParam(1)->getVariableTyp() != BOOLEAN)
			return;
		Boolean* b1 = (Boolean*)zParam(0);
		Boolean* b2 = (Boolean*)zParam(1);
		if (op == UND)
			setReturn(new Boolean(b1->getValue() && b2->getValue()));
		else
			setReturn(new Boolean(b1->getValue() || b2->getValue()));
	}
	if (op == GLEICH || op == UNGLEICH)
	{
		if (zParam(1)->getVariableTyp() != zParam(0)->getVariableTyp())
		{
			setReturn(new Boolean(op == GLEICH));
			return;
		}
		switch (zParam(0)->getVariableTyp())
		{
		case NICHTS:
			setReturn(new Boolean(op == GLEICH));
			break;
		case INTEGER:
			setReturn(new Boolean((op == GLEICH) == (((Integer*)zParam(0))->getValue() == ((Integer*)zParam(1))->getValue())));
			break;
		case BOOLEAN:
			setReturn(new Boolean((op == GLEICH) == (((Boolean*)zParam(0))->getValue() == ((Boolean*)zParam(1))->getValue())));
			break;
		case STRING:
			setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
			break;
		case RICHTUNG:
			setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
			break;
		case FLOAT:
			setReturn(new Boolean((op == GLEICH) == (((Float*)zParam(0))->getValue() == ((Float*)zParam(1))->getValue())));
			break;
		case TASTE:
			setReturn(new Boolean((op == GLEICH) == (((Integer*)zParam(0))->getValue() == ((Integer*)zParam(1))->getValue())));
			break;
		case GEGENSTAND_TYP:
			setReturn(new Boolean((op == GLEICH) == (((GegenstandTypVar*)zParam(0))->getValue() == ((GegenstandTypVar*)zParam(1))->getValue())));
			break;
		case GESCHOSS_TYP:
			setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
			break;
		default:
			setReturn(new Boolean((op == GLEICH) == (zParam(0) == zParam(1))));
		}
	}
	if (op == GREATER || op == SMALLER || op == GREATER_OR_EQUAL || op == SMALLER_OR_EQUAL)
	{
		if (zParam(1)->getVariableTyp() != zParam(0)->getVariableTyp())
		{
			setReturn(new Boolean(op == GLEICH));
			return;
		}
		if (zParam(1)->getVariableTyp() == INTEGER)
		{
			if (op == SMALLER || op == GREATER_OR_EQUAL)
				setReturn(new Boolean((op == SMALLER) == (((Integer*)zParam(0))->getValue() < ((Integer*)zParam(1))->getValue())));
			else
				setReturn(new Boolean((op == GREATER) == (((Integer*)zParam(0))->getValue() > ((Integer*)zParam(1))->getValue())));
		}
		if (zParam(1)->getVariableTyp() == FLOAT)
		{
			if (op == SMALLER || op == GREATER_OR_EQUAL)
				setReturn(new Boolean((op == SMALLER) == (((Float*)zParam(0))->getValue() < ((Float*)zParam(1))->getValue())));
			else
				setReturn(new Boolean((op == GREATER) == (((Float*)zParam(0))->getValue() > ((Float*)zParam(1))->getValue())));
		}
	}
	if (op == INVERT_BOOL)
	{
		setReturn(new Boolean(!((Boolean*)zParam(0))->getValue()));
	}
}

void BooleanRechnung::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&this->op, 1);
}


Sequenz::Sequenz(RCArray< Aktion >* subActions)
	: Aktion(SEQUENZ, subActions)
{}

void Sequenz::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{}


FloatRechnung::FloatRechnung(RCArray< Aktion >* subActions, Operator op)
	: Aktion(FLOAT_RECHNUNG, subActions)
{
	this->op = op;
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(FLOAT);
}

void FloatRechnung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Float* l = (Float*)zParam(0);
	Float* r = (Float*)zParam(1);
	switch (op)
	{
	case PLUS:
		setReturn(new Float(l->getValue() + r->getValue()));
		break;
	case MINUS:
		setReturn(new Float(l->getValue() - r->getValue()));
		break;
	case MAHL:
		setReturn(new Float(l->getValue() * r->getValue()));
		break;
	case GETEILT:
		setReturn(new Float(l->getValue() / r->getValue()));
		break;
	case HOCH:
		setReturn(new Float((float)pow(l->getValue(), r->getValue())));
		break;
	case WURZEL:
		setReturn(new Float((float)pow(l->getValue(), 1.0 / r->getValue())));
		break;
	case INVERT_SIGN:
		setReturn(new Float(-l->getValue()));
		break;
	case PLUS_PLUS_LEFT:
		l->setValue(l->getValue() + 1);
		setReturn(new Float(l->getValue()));
		break;
	case PLUS_PLUS_RIGHT:
	{
		float tmp = l->getValue();
		l->setValue(l->getValue() + 1);
		setReturn(new Float(tmp));
		break;
	}
	case MINUS_MINUS_LEFT:
		l->setValue(l->getValue() - 1);
		setReturn(new Float(l->getValue()));
		break;
	case MINUS_MINUS_RIGHT:
	{
		float tmp = l->getValue();
		l->setValue(l->getValue() - 1);
		setReturn(new Float(tmp));
		break;
	}
	case LOGARITHM:
		setReturn(new Float((float)(log(l->getValue()) / log(r->getValue()))));
		break;
	case MODULO:
		setReturn(new Float(l->getValue() - (float)(int)(l->getValue() / r->getValue()) * r->getValue()));
		break;
	default:
		break;
	}
}

void FloatRechnung::writeOptions(StreamWriter& dat)
{
	dat.schreibe((char*)&op, 1);
}


FloatAusInteger::FloatAusInteger(RCArray< Aktion >* subActions)
	: Aktion(FLOAT_AUS_INTEGER, subActions)
{
	erlaubteTypen.add(INTEGER);
}

void FloatAusInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float((float)((Integer*)zParam(0))->getValue()));
}


FloatAusText::FloatAusText(RCArray< Aktion >* subActions)
	: Aktion(FLOAT_AUS_TEXT, subActions)
{
	erlaubteTypen.add(STRING);
}

void FloatAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Float((float)((String*)zParam(0))->getValue()));
}


TextAusFloat::TextAusFloat(RCArray< Aktion >* subActions)
	: Aktion(TEXT_AUS_FLOAT, subActions)
{
	erlaubteTypen.add(FLOAT);
}

void TextAusFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(Text(((Float*)zParam(0))->getValue())));
}


FloatZufall::FloatZufall(RCArray< Aktion >* subActions)
	: Aktion(FLOAT_ZUFALL, subActions)
{
	erlaubteTypen.add(FLOAT);
	erlaubteTypen.add(FLOAT);
}

void FloatZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Float* min = ((Float*)zParam(0));
	Float* max = ((Float*)zParam(0));
	setReturn(new Float((float)zSpiel->getRand() * (max->getValue() - min->getValue()) + min->getValue()));
}


IntegerAusFloat::IntegerAusFloat(RCArray< Aktion >* subActions)
	: Aktion(INTEGER_AUS_FLOAT, subActions)
{
	erlaubteTypen.add(FLOAT);
}

void IntegerAusFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new Integer((int)((Float*)zParam(0))->getValue()));
}


BestenlisteNeu::BestenlisteNeu(RCArray<Aktion>* subActions)
	: Aktion(BESTENLISTE_NEU, subActions)
{}

void BestenlisteNeu::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Bestenliste* b = new Bestenliste(zSpiel->getNextId(), zSpiel->zResources()->getUIFactory());
	zSpiel->addBestenliste(b);
	setReturn(dynamic_cast<Bestenliste*>(b->getThis()));
}


BestenlisteAddZeile::BestenlisteAddZeile(RCArray<Aktion>* subActions)
	: Aktion(BESTENLISTE_ADD_ZEILE, subActions)
{
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(BESTENLISTE);
}

void BestenlisteAddZeile::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Bestenliste*)zParam(1))->addZeile(((String*)zParam(0))->getValue());
}


BestenlisteAddSpalte::BestenlisteAddSpalte(RCArray<Aktion>* subActions)
	: Aktion(BESTENLISTE_ADD_SPALTE, subActions)
{
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(BESTENLISTE);
}

void BestenlisteAddSpalte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Bestenliste*)zParam(1))->addSpalte(((String*)zParam(0))->getValue());
}


BestenlisteSetWert::BestenlisteSetWert(RCArray<Aktion>* subActions)
	: Aktion(BESTENLISTE_SET_WERT, subActions)
{
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(BESTENLISTE);
}

void BestenlisteSetWert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	((Bestenliste*)zParam(3))->setWert(((String*)zParam(0))->getValue(), ((String*)zParam(1))->getValue(), ((String*)zParam(2))->getValue());
}


BestenlisteGetWert::BestenlisteGetWert(RCArray<Aktion>* subActions)
	: Aktion(BESTENLISTE_GET_WERT, subActions)
{
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(STRING);
	erlaubteTypen.add(BESTENLISTE);
}

void BestenlisteGetWert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(new String(((Bestenliste*)zParam(2))->getWert(((String*)zParam(0))->getValue(), ((String*)zParam(1))->getValue())));
}


SchalterMitNummer::SchalterMitNummer(RCArray<Aktion>* subActions)
	: Aktion(SCHALTER_MIT_NUMMER, subActions)
{
	erlaubteTypen.add(INTEGER);
}

void SchalterMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Schalter* s = zSpiel->getSchalter(((Integer*)zParam(0))->getValue());
	if (s)
		setReturn(s);
	else
		setReturn(new Variable(VariableTyp::NICHTS));
}


BaseMitNummer::BaseMitNummer(RCArray<Aktion>* subActions)
	: Aktion(BASE_MIT_NUMMER, subActions)
{
	erlaubteTypen.add(INTEGER);
}

void BaseMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Base* b = zSpiel->getBase(((Integer*)zParam(0))->getValue());
	if (b)
		setReturn(b);
	else
		setReturn(new Variable(VariableTyp::NICHTS));
}


TeamMitNummer::TeamMitNummer(RCArray<Aktion>* subActions)
	: Aktion(TEAM_MIT_NUMMER, subActions)
{
	erlaubteTypen.add(INTEGER);
}

void TeamMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	setReturn(zSpiel->getTeam(((Integer*)zParam(0))->getValue()));
}


TeamVonBase::TeamVonBase(RCArray<Aktion>* subActions)
	: Aktion(TEAM_VON_BASE, subActions)
{
	erlaubteTypen.add(BASE);
}

void TeamVonBase::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Team* t = ((Base*)zParam(0))->getTeam();
	if (t)
		setReturn(t);
	else
		setReturn(new Variable(VariableTyp::NICHTS));
}


SpielerMitNummer::SpielerMitNummer(RCArray<Aktion>* subActions)
	: Aktion(SPIELER_MIT_NUMMER, subActions)
{
	erlaubteTypen.add(INTEGER);
}

void SpielerMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
{
	Spieler* s = zSpiel->getSpieler(((Integer*)zParam(0))->getValue());
	if (s)
		setReturn(s);
	else
		setReturn(new Variable(VariableTyp::NICHTS));
}